Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
  jpmschweitzerandClaude Opus 4.5
|
afb47c48d4 | ||
|
jpmschweitzerandClaude Opus 4.5
|
a22e168666 | ||
|
jpmschweitzerandClaude Opus 4.5
|
33f31b09a3 | ||
|
jpmschweitzerandClaude Opus 4.5
|
c45fdcb528 |
@@ -5,6 +5,42 @@ All notable changes to this project will be documented in this file.
|
||||
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
|
||||
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
|
||||
|
||||
## [1.2.0] - 2025-12-17
|
||||
|
||||
### Added
|
||||
|
||||
- **Housekeeping API** - Home Assistant integration for smart home control
|
||||
- `GET /housekeeping/health` - HA connection status
|
||||
- `GET /housekeeping/devices` - List controllable devices with optional domain/area filtering
|
||||
- `GET /housekeeping/devices/{entity_id}` - Get device details
|
||||
- `POST /housekeeping/devices/{entity_id}/control` - Control devices (turn_on, turn_off, toggle, set_brightness)
|
||||
- `GET /housekeeping/scenes` - List available scenes
|
||||
- `POST /housekeeping/scenes/{scene_id}/activate` - Activate a scene
|
||||
- `GET /housekeeping/scripts` - List available scripts
|
||||
- `POST /housekeeping/scripts/{script_id}/run` - Run a script
|
||||
- `GET /housekeeping/automations` - List automations
|
||||
- `POST /housekeeping/automations/{automation_id}/toggle` - Enable/disable automation
|
||||
- `GET /housekeeping/history` - Query state history
|
||||
- `GET /housekeeping/areas` - List rooms/areas
|
||||
- Home Assistant REST API client (`src/clients/homeassistant_client.py`)
|
||||
- Home Assistant configuration in credentials and settings
|
||||
- Comprehensive test suite with 65% code coverage (285 tests)
|
||||
- Tests for NPM client, Ollama client, AI client, OIDC authentication
|
||||
- Tests for infrastructure, health, tools, and housekeeping endpoints
|
||||
|
||||
### Removed
|
||||
|
||||
- **Web Scraper** - Entire web scraping module removed
|
||||
- `src/web_scraper/` directory deleted
|
||||
- `/web-scraper/scrape` endpoint removed
|
||||
- Trafilatura and BeautifulSoup dependencies removed from scraping use
|
||||
|
||||
### Changed
|
||||
|
||||
- Updated README.md with current architecture and all endpoints
|
||||
- Tools controller now only contains DNS lookup functionality
|
||||
- Health controller endpoints list updated to reflect current features
|
||||
|
||||
## [1.1.2] - 2024-12-14
|
||||
|
||||
### Added
|
||||
|
||||
@@ -1,15 +1,26 @@
|
||||
# Core Code API
|
||||
|
||||
OpenAPI-compatible functions for Open WebUI, providing web scraping and data processing capabilities.
|
||||
Central API service providing infrastructure management, home automation, and utility endpoints for the homelab ecosystem.
|
||||
|
||||
## Features
|
||||
|
||||
### Web Scraper
|
||||
- Intelligent content extraction using Trafilatura
|
||||
- BeautifulSoup fallback for complex pages
|
||||
- Configurable content length limits
|
||||
- Optional link extraction
|
||||
- Perfect for feeding webpage content to LLMs
|
||||
### Infrastructure Management
|
||||
- **Portainer Integration**: Stack and container management
|
||||
- **NPM Integration**: Nginx Proxy Manager domain and certificate management
|
||||
- **Service Control**: Start/stop services with container orchestration
|
||||
|
||||
### Home Automation (Housekeeping API)
|
||||
- **Device Control**: Turn on/off, toggle, and set brightness for smart devices
|
||||
- **Scene Activation**: Trigger Home Assistant scenes
|
||||
- **Script Execution**: Run Home Assistant scripts
|
||||
- **Automation Management**: Enable/disable automations
|
||||
- **State History**: Query device state changes over time
|
||||
- **Area Discovery**: List rooms and areas
|
||||
|
||||
### Utilities
|
||||
- **DNS Lookup**: Query DNS records (A, AAAA, MX, TXT, CNAME, NS, SOA, PTR)
|
||||
- **Health Checks**: Comprehensive service health monitoring
|
||||
- **AI Metrics Proxy**: Forward metrics requests to Core-AI service
|
||||
|
||||
## Architecture
|
||||
|
||||
@@ -17,17 +28,69 @@ OpenAPI-compatible functions for Open WebUI, providing web scraping and data pro
|
||||
src/
|
||||
├── config.py # Global application settings
|
||||
├── logging_config.py # Logging configuration
|
||||
├── base_schema.py # Base Pydantic models
|
||||
├── base_controller.py # Base controller pattern
|
||||
├── main.py # FastAPI application entry point
|
||||
└── web_scraper/ # Web scraper module
|
||||
├── __init__.py
|
||||
├── config.py # Module-specific settings
|
||||
├── schemas.py # Pydantic request/response models
|
||||
├── service.py # Business logic
|
||||
├── router.py # API routes
|
||||
└── exceptions.py # Custom exceptions
|
||||
├── auth/
|
||||
│ └── oidc.py # OIDC authentication
|
||||
├── clients/
|
||||
│ ├── homeassistant_client.py # Home Assistant REST client
|
||||
│ ├── npm_client.py # Nginx Proxy Manager client
|
||||
│ ├── ollama_client.py # Ollama LLM client
|
||||
│ └── portainer_client.py # Portainer API client
|
||||
├── controllers/
|
||||
│ ├── ai_controller.py # AI metrics proxy
|
||||
│ ├── health_controller.py # Health endpoints
|
||||
│ ├── housekeeping_controller.py # Home automation endpoints
|
||||
│ ├── infrastructure_controller.py # Infrastructure management
|
||||
│ ├── static_controller.py # Static file serving
|
||||
│ └── tools_controller.py # DNS and utility tools
|
||||
└── dns/
|
||||
├── service.py # DNS lookup service
|
||||
└── exceptions.py # DNS-specific exceptions
|
||||
```
|
||||
|
||||
## API Endpoints
|
||||
|
||||
### Health
|
||||
- `GET /` - Service info and documentation links
|
||||
- `GET /health` - Basic health status
|
||||
- `GET /health/full` - Detailed component health
|
||||
- `GET /health/diagnostics` - Full diagnostic information
|
||||
|
||||
### Infrastructure (`/infrastructure`)
|
||||
- `GET /infrastructure/health` - Portainer/NPM connection status
|
||||
- `GET /infrastructure/services` - List all services (stacks)
|
||||
- `GET /infrastructure/services/{name}` - Get service details
|
||||
- `GET /infrastructure/services/{name}/status` - Service status
|
||||
- `POST /infrastructure/services/{name}/start` - Start service
|
||||
- `POST /infrastructure/services/{name}/stop` - Stop service
|
||||
- `GET /infrastructure/containers` - List containers
|
||||
- `GET /infrastructure/containers/{name}` - Container details
|
||||
- `GET /infrastructure/containers/{name}/logs` - Container logs
|
||||
- `GET /infrastructure/ports` - List exposed ports
|
||||
- `GET /infrastructure/domains` - List proxy domains
|
||||
- `GET /infrastructure/widget-data` - Dashboard widget data
|
||||
|
||||
### Housekeeping (`/housekeeping`)
|
||||
- `GET /housekeeping/health` - Home Assistant connection status
|
||||
- `GET /housekeeping/devices` - List controllable devices
|
||||
- `GET /housekeeping/devices/{entity_id}` - Device details
|
||||
- `POST /housekeeping/devices/{entity_id}/control` - Control device
|
||||
- `GET /housekeeping/scenes` - List scenes
|
||||
- `POST /housekeeping/scenes/{scene_id}/activate` - Activate scene
|
||||
- `GET /housekeeping/scripts` - List scripts
|
||||
- `POST /housekeeping/scripts/{script_id}/run` - Run script
|
||||
- `GET /housekeeping/automations` - List automations
|
||||
- `POST /housekeeping/automations/{automation_id}/toggle` - Toggle automation
|
||||
- `GET /housekeeping/history` - State history
|
||||
- `GET /housekeeping/areas` - List areas/rooms
|
||||
|
||||
### Tools (`/tools`)
|
||||
- `POST /tools/dns/lookup` - DNS record lookup
|
||||
|
||||
### AI (`/ai`)
|
||||
- `GET /ai/metrics` - Proxy to Core-AI metrics
|
||||
|
||||
## Development
|
||||
|
||||
### Requirements
|
||||
@@ -40,13 +103,30 @@ src/
|
||||
# Install dependencies
|
||||
pip install -r requirements.txt
|
||||
|
||||
# Copy credentials template
|
||||
cp src/credentials.example.py src/credentials.py
|
||||
# Edit src/credentials.py with your values
|
||||
|
||||
# Run locally
|
||||
uvicorn src.main:app --reload --host 0.0.0.0 --port 8083
|
||||
```
|
||||
|
||||
### Running Tests
|
||||
|
||||
```bash
|
||||
# Run all tests
|
||||
pytest
|
||||
|
||||
# Run with coverage
|
||||
pytest --cov=src --cov-report=term-missing
|
||||
|
||||
# Run specific test file
|
||||
pytest tests/test_housekeeping.py -v
|
||||
```
|
||||
|
||||
### Adding New Dependencies
|
||||
|
||||
**Important**: Dependencies use major version pinning (`~=`) for automatic patch updates while preventing breaking changes.
|
||||
Dependencies use major version pinning (`~=`) for automatic patch updates while preventing breaking changes.
|
||||
|
||||
1. Add package to `requirements.txt` with major version constraint:
|
||||
```
|
||||
@@ -58,14 +138,6 @@ uvicorn src.main:app --reload --host 0.0.0.0 --port 8083
|
||||
docker restart core-api
|
||||
```
|
||||
|
||||
The container automatically runs `pip install -r requirements.txt` on every boot, so new dependencies are installed immediately on restart.
|
||||
|
||||
**Version Pinning Best Practices**:
|
||||
- Use `~=` (compatible release) for most packages: `fastapi~=0.115.0`
|
||||
- Use `>=X,<Y` for complex constraints: `langchain-core>=0.3.17,<0.4.0`
|
||||
- Allows automatic security patches without breaking changes
|
||||
- Documented in PEP 440
|
||||
|
||||
### Docker Build
|
||||
|
||||
```bash
|
||||
@@ -88,130 +160,39 @@ docker run -p 8083:8083 core-code:latest
|
||||
|
||||
### Environment Variables
|
||||
|
||||
See `.env.example` for all available configuration options.
|
||||
| Variable | Description | Default |
|
||||
|----------|-------------|---------|
|
||||
| `PORTAINER_URL` | Portainer API URL | `http://localhost:9000` |
|
||||
| `PORTAINER_API_KEY` | Portainer API key | - |
|
||||
| `NPM_URL` | Nginx Proxy Manager URL | `http://localhost:81` |
|
||||
| `NPM_EMAIL` | NPM admin email | - |
|
||||
| `NPM_PASSWORD` | NPM admin password | - |
|
||||
| `HOMEASSISTANT_URL` | Home Assistant URL | `http://localhost:8123` |
|
||||
| `HOMEASSISTANT_TOKEN` | HA long-lived access token | - |
|
||||
| `OLLAMA_URL` | Ollama API URL | `http://localhost:11434` |
|
||||
| `OIDC_ENABLED` | Enable OIDC auth | `false` |
|
||||
| `OIDC_ISSUER` | OIDC issuer URL | - |
|
||||
| `OIDC_AUDIENCE` | OIDC audience | - |
|
||||
|
||||
## API Documentation
|
||||
|
||||
Once deployed, access documentation at:
|
||||
- **Swagger UI**: http://192.168.86.149:8083/docs
|
||||
- **ReDoc**: http://192.168.86.149:8083/redoc
|
||||
- **OpenAPI Spec**: http://192.168.86.149:8083/openapi.json
|
||||
|
||||
## Integration with Open WebUI
|
||||
|
||||
### Method 1: Functions (OpenAPI Import)
|
||||
1. In Open WebUI, navigate to Functions
|
||||
2. Import from OpenAPI spec: `http://192.168.86.149:8083/openapi.json`
|
||||
3. Use functions directly in chat
|
||||
|
||||
### Method 2: Pipelines
|
||||
1. Create a pipeline that calls Core Code API endpoints
|
||||
2. Use as data source for LLM workflows
|
||||
|
||||
### Method 3: Direct API Calls
|
||||
```python
|
||||
import httpx
|
||||
|
||||
async with httpx.AsyncClient() as client:
|
||||
response = await client.post(
|
||||
"http://192.168.86.149:8083/web-scraper/scrape",
|
||||
json={
|
||||
"url": "https://example.com",
|
||||
"extract_main_content": True
|
||||
}
|
||||
)
|
||||
data = response.json()
|
||||
```
|
||||
|
||||
## API Endpoints
|
||||
|
||||
### Web Scraper
|
||||
|
||||
**POST /web-scraper/scrape**
|
||||
|
||||
Scrape and extract content from a website.
|
||||
|
||||
Request:
|
||||
```json
|
||||
{
|
||||
"url": "https://example.com/article",
|
||||
"extract_main_content": true,
|
||||
"include_links": false,
|
||||
"max_length": 10000
|
||||
}
|
||||
```
|
||||
|
||||
Response:
|
||||
```json
|
||||
{
|
||||
"url": "https://example.com/article",
|
||||
"title": "Article Title",
|
||||
"content": "Extracted article content...",
|
||||
"extracted_at": "2025-11-12T19:30:00Z",
|
||||
"content_length": 5432,
|
||||
"links": null
|
||||
}
|
||||
```
|
||||
|
||||
## Logging
|
||||
|
||||
Logs are written to:
|
||||
- **Console**: stdout (captured by Docker)
|
||||
- **File**: `/app/logs/app.log` (persisted via volume mount)
|
||||
|
||||
Log format:
|
||||
```
|
||||
2025-11-12 19:30:00 | INFO | src.web_scraper.service:scrape_url:45 | Starting scrape for URL: https://example.com
|
||||
```
|
||||
- **Swagger UI**: http://localhost:8083/docs
|
||||
- **ReDoc**: http://localhost:8083/redoc
|
||||
- **OpenAPI Spec**: http://localhost:8083/openapi.json
|
||||
|
||||
## Health Checks
|
||||
|
||||
- **Endpoint**: `GET /health`
|
||||
- **Docker**: Automatic health checks configured
|
||||
- **Response**: `{"status": "healthy"}`
|
||||
- **Basic**: `GET /health` - Returns status and Ollama connection
|
||||
- **Full**: `GET /health/full` - Returns all component statuses (503 if unhealthy)
|
||||
- **Diagnostics**: `GET /health/diagnostics` - Detailed service information
|
||||
|
||||
## Security
|
||||
|
||||
- Runs as non-root user (uid 1000)
|
||||
- No authentication required (internal network only)
|
||||
- OIDC authentication support via Authentik
|
||||
- CORS configured for same-network access
|
||||
- Rate limiting: Not implemented (internal use only)
|
||||
|
||||
## Future Modules
|
||||
|
||||
The architecture supports adding new modules:
|
||||
- Data transformation functions
|
||||
- API integrations
|
||||
- File processing
|
||||
- Database queries
|
||||
|
||||
Each module follows the same structure:
|
||||
```
|
||||
src/
|
||||
└── module_name/
|
||||
├── config.py
|
||||
├── schemas.py
|
||||
├── service.py
|
||||
├── router.py
|
||||
└── exceptions.py
|
||||
```
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Container won't start
|
||||
```bash
|
||||
docker logs core-code
|
||||
```
|
||||
|
||||
### API not responding
|
||||
```bash
|
||||
curl http://192.168.86.149:8083/health
|
||||
```
|
||||
|
||||
### Check OpenAPI spec
|
||||
```bash
|
||||
curl http://192.168.86.149:8083/openapi.json | jq
|
||||
```
|
||||
- Admin endpoints require authentication when OIDC enabled
|
||||
|
||||
## License
|
||||
|
||||
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
[project]
|
||||
name = "core-api"
|
||||
version = "1.1.2"
|
||||
version = "1.2.0"
|
||||
description = "Core Code API - Infrastructure management and tools API"
|
||||
readme = "README.md"
|
||||
requires-python = ">=3.12"
|
||||
|
||||
@@ -0,0 +1,409 @@
|
||||
"""
|
||||
Home Assistant REST API Client
|
||||
|
||||
Provides interface to Home Assistant REST API for home automation control.
|
||||
Uses long-lived access token authentication.
|
||||
API Reference: https://developers.home-assistant.io/docs/api/rest/
|
||||
"""
|
||||
import httpx
|
||||
import json
|
||||
from typing import Optional, Dict, List, Any
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from src.logging_config import get_logger
|
||||
from src.config import get_settings
|
||||
|
||||
logger = get_logger(__name__)
|
||||
settings = get_settings()
|
||||
|
||||
|
||||
class HomeAssistantClient:
|
||||
"""
|
||||
HTTP client for Home Assistant REST API
|
||||
|
||||
Uses long-lived access token authentication via Bearer token.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
base_url: Optional[str] = None,
|
||||
token: Optional[str] = None,
|
||||
timeout: int = 30
|
||||
):
|
||||
"""
|
||||
Initialize Home Assistant client
|
||||
|
||||
Args:
|
||||
base_url: Home Assistant base URL (default from settings)
|
||||
token: Long-lived access token (default from settings)
|
||||
timeout: Request timeout in seconds
|
||||
"""
|
||||
self.base_url = (base_url or settings.homeassistant_url).rstrip("/")
|
||||
self.token = token or settings.homeassistant_token
|
||||
self.timeout = timeout
|
||||
|
||||
if not self.token:
|
||||
logger.warning("Home Assistant token not configured")
|
||||
|
||||
def _get_headers(self) -> Dict[str, str]:
|
||||
"""Get request headers with Bearer token authentication"""
|
||||
return {
|
||||
"Authorization": f"Bearer {self.token}",
|
||||
"Content-Type": "application/json"
|
||||
}
|
||||
|
||||
# ========================================================================
|
||||
# Health & Discovery
|
||||
# ========================================================================
|
||||
|
||||
async def health_check(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Check Home Assistant API connectivity and get version info
|
||||
|
||||
HA Endpoint: GET /api/
|
||||
|
||||
Returns:
|
||||
Dict with connected status, platform name, and version
|
||||
"""
|
||||
try:
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.get(
|
||||
f"{self.base_url}/api/",
|
||||
headers=self._get_headers()
|
||||
)
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
return {
|
||||
"status": "healthy",
|
||||
"connected": True,
|
||||
"platform": "home_assistant",
|
||||
"version": data.get("version", "unknown")
|
||||
}
|
||||
return {
|
||||
"status": "unhealthy",
|
||||
"connected": False,
|
||||
"platform": "home_assistant",
|
||||
"error": f"HTTP {response.status_code}"
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"Home Assistant health check failed: {e}")
|
||||
return {
|
||||
"status": "unhealthy",
|
||||
"connected": False,
|
||||
"platform": "home_assistant",
|
||||
"error": str(e)
|
||||
}
|
||||
|
||||
async def get_states(self) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Get all entity states
|
||||
|
||||
HA Endpoint: GET /api/states
|
||||
|
||||
Returns:
|
||||
List of all entity states
|
||||
"""
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.get(
|
||||
f"{self.base_url}/api/states",
|
||||
headers=self._get_headers()
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
|
||||
async def get_state(self, entity_id: str) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Get state of a specific entity
|
||||
|
||||
HA Endpoint: GET /api/states/<entity_id>
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID (e.g., "light.living_room")
|
||||
|
||||
Returns:
|
||||
Entity state dict or None if not found
|
||||
"""
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.get(
|
||||
f"{self.base_url}/api/states/{entity_id}",
|
||||
headers=self._get_headers()
|
||||
)
|
||||
if response.status_code == 404:
|
||||
return None
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
|
||||
async def get_config(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Get Home Assistant configuration (includes areas)
|
||||
|
||||
HA Endpoint: GET /api/config
|
||||
|
||||
Returns:
|
||||
Configuration dict including components, location, etc.
|
||||
"""
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.get(
|
||||
f"{self.base_url}/api/config",
|
||||
headers=self._get_headers()
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
|
||||
# ========================================================================
|
||||
# Device Control
|
||||
# ========================================================================
|
||||
|
||||
async def call_service(
|
||||
self,
|
||||
domain: str,
|
||||
service: str,
|
||||
entity_id: Optional[str] = None,
|
||||
service_data: Optional[Dict[str, Any]] = None
|
||||
) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Call a Home Assistant service
|
||||
|
||||
HA Endpoint: POST /api/services/<domain>/<service>
|
||||
|
||||
Args:
|
||||
domain: Service domain (e.g., "light", "switch", "scene")
|
||||
service: Service name (e.g., "turn_on", "turn_off", "toggle")
|
||||
entity_id: Target entity ID (optional for some services)
|
||||
service_data: Additional service data/attributes
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
payload = service_data.copy() if service_data else {}
|
||||
if entity_id:
|
||||
payload["entity_id"] = entity_id
|
||||
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.post(
|
||||
f"{self.base_url}/api/services/{domain}/{service}",
|
||||
headers=self._get_headers(),
|
||||
json=payload
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
|
||||
async def turn_on(
|
||||
self,
|
||||
entity_id: str,
|
||||
**attributes
|
||||
) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Turn on an entity with optional attributes
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID (e.g., "light.living_room")
|
||||
**attributes: Additional attributes (brightness, color_temp, etc.)
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
domain = entity_id.split(".")[0]
|
||||
return await self.call_service(
|
||||
domain=domain,
|
||||
service="turn_on",
|
||||
entity_id=entity_id,
|
||||
service_data=attributes if attributes else None
|
||||
)
|
||||
|
||||
async def turn_off(self, entity_id: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Turn off an entity
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
domain = entity_id.split(".")[0]
|
||||
return await self.call_service(
|
||||
domain=domain,
|
||||
service="turn_off",
|
||||
entity_id=entity_id
|
||||
)
|
||||
|
||||
async def toggle(self, entity_id: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Toggle an entity
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
domain = entity_id.split(".")[0]
|
||||
return await self.call_service(
|
||||
domain=domain,
|
||||
service="toggle",
|
||||
entity_id=entity_id
|
||||
)
|
||||
|
||||
# ========================================================================
|
||||
# Scenes
|
||||
# ========================================================================
|
||||
|
||||
async def activate_scene(self, scene_id: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Activate a scene
|
||||
|
||||
Args:
|
||||
scene_id: Scene entity ID (e.g., "scene.movie_night")
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
return await self.call_service(
|
||||
domain="scene",
|
||||
service="turn_on",
|
||||
entity_id=scene_id
|
||||
)
|
||||
|
||||
# ========================================================================
|
||||
# Scripts
|
||||
# ========================================================================
|
||||
|
||||
async def run_script(
|
||||
self,
|
||||
script_id: str,
|
||||
variables: Optional[Dict[str, Any]] = None
|
||||
) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Execute a script with optional variables
|
||||
|
||||
Args:
|
||||
script_id: Script entity ID (e.g., "script.bedtime_routine")
|
||||
variables: Script variables
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
service_data = {"variables": variables} if variables else None
|
||||
return await self.call_service(
|
||||
domain="script",
|
||||
service="turn_on",
|
||||
entity_id=script_id,
|
||||
service_data=service_data
|
||||
)
|
||||
|
||||
# ========================================================================
|
||||
# Automations
|
||||
# ========================================================================
|
||||
|
||||
async def enable_automation(self, automation_id: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Enable an automation
|
||||
|
||||
Args:
|
||||
automation_id: Automation entity ID
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
return await self.call_service(
|
||||
domain="automation",
|
||||
service="turn_on",
|
||||
entity_id=automation_id
|
||||
)
|
||||
|
||||
async def disable_automation(self, automation_id: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Disable an automation
|
||||
|
||||
Args:
|
||||
automation_id: Automation entity ID
|
||||
|
||||
Returns:
|
||||
List of changed states
|
||||
"""
|
||||
return await self.call_service(
|
||||
domain="automation",
|
||||
service="turn_off",
|
||||
entity_id=automation_id
|
||||
)
|
||||
|
||||
# ========================================================================
|
||||
# History
|
||||
# ========================================================================
|
||||
|
||||
async def get_history(
|
||||
self,
|
||||
entity_id: str,
|
||||
hours: int = 24
|
||||
) -> List[List[Dict[str, Any]]]:
|
||||
"""
|
||||
Get state history for an entity
|
||||
|
||||
HA Endpoint: GET /api/history/period/<timestamp>
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID to get history for
|
||||
hours: Number of hours of history (default 24)
|
||||
|
||||
Returns:
|
||||
List of state history entries
|
||||
"""
|
||||
start_time = datetime.now(timezone.utc) - timedelta(hours=hours)
|
||||
timestamp = start_time.isoformat()
|
||||
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.get(
|
||||
f"{self.base_url}/api/history/period/{timestamp}",
|
||||
headers=self._get_headers(),
|
||||
params={
|
||||
"filter_entity_id": entity_id,
|
||||
"minimal_response": "true"
|
||||
}
|
||||
)
|
||||
response.raise_for_status()
|
||||
return response.json()
|
||||
|
||||
# ========================================================================
|
||||
# Areas (via template API)
|
||||
# ========================================================================
|
||||
|
||||
async def get_areas(self) -> List[Dict[str, str]]:
|
||||
"""
|
||||
Get all areas/rooms
|
||||
|
||||
Note: The REST API doesn't have a direct areas endpoint.
|
||||
This uses the template API to render area data.
|
||||
|
||||
HA Endpoint: POST /api/template
|
||||
|
||||
Returns:
|
||||
List of area dicts with id and name
|
||||
"""
|
||||
template = """
|
||||
{% set areas_list = [] %}
|
||||
{% for area in areas() %}
|
||||
{% set areas_list = areas_list + [{"id": area, "name": area_name(area)}] %}
|
||||
{% endfor %}
|
||||
{{ areas_list | tojson }}
|
||||
"""
|
||||
async with httpx.AsyncClient(timeout=self.timeout) as client:
|
||||
response = await client.post(
|
||||
f"{self.base_url}/api/template",
|
||||
headers=self._get_headers(),
|
||||
json={"template": template}
|
||||
)
|
||||
response.raise_for_status()
|
||||
# Response is rendered template as string
|
||||
return json.loads(response.text)
|
||||
|
||||
|
||||
# Singleton instance
|
||||
_homeassistant_client: Optional[HomeAssistantClient] = None
|
||||
|
||||
|
||||
def get_homeassistant_client() -> HomeAssistantClient:
|
||||
"""Get singleton Home Assistant client instance"""
|
||||
global _homeassistant_client
|
||||
if _homeassistant_client is None:
|
||||
_homeassistant_client = HomeAssistantClient()
|
||||
return _homeassistant_client
|
||||
+9
-1
@@ -26,7 +26,8 @@ try:
|
||||
PORTAINER_URL, PORTAINER_API_KEY,
|
||||
NPM_URL, NPM_EMAIL, NPM_PASSWORD,
|
||||
BRAVE_SEARCH_API_KEY,
|
||||
GOOGLE_SEARCH_API_KEY, GOOGLE_SEARCH_ENGINE_ID
|
||||
GOOGLE_SEARCH_API_KEY, GOOGLE_SEARCH_ENGINE_ID,
|
||||
HOMEASSISTANT_URL, HOMEASSISTANT_TOKEN
|
||||
)
|
||||
except ImportError:
|
||||
# Fallback to empty strings if credentials.py doesn't exist
|
||||
@@ -39,6 +40,8 @@ except ImportError:
|
||||
BRAVE_SEARCH_API_KEY = ""
|
||||
GOOGLE_SEARCH_API_KEY = ""
|
||||
GOOGLE_SEARCH_ENGINE_ID = ""
|
||||
HOMEASSISTANT_URL = "http://localhost:8123"
|
||||
HOMEASSISTANT_TOKEN = ""
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
@@ -122,6 +125,11 @@ class Settings(BaseSettings):
|
||||
npm_email: str = NPM_EMAIL
|
||||
npm_password: str = NPM_PASSWORD
|
||||
|
||||
# Home Assistant Configuration
|
||||
homeassistant_url: str = HOMEASSISTANT_URL
|
||||
homeassistant_token: str = HOMEASSISTANT_TOKEN
|
||||
homeassistant_timeout: int = 30
|
||||
|
||||
# Core-AI Service (AI performance metrics)
|
||||
core_ai_base_url: str = "http://core-ai:8086"
|
||||
|
||||
|
||||
@@ -61,7 +61,7 @@ class HealthController(BaseController):
|
||||
"chat_completions": "/v1/chat/completions",
|
||||
"models": "/v1/models",
|
||||
"conversations": "/v1/conversations",
|
||||
"web_scraper": "/web-scraper/scrape",
|
||||
"dns_lookup": "/tools/dns/lookup",
|
||||
"infrastructure": "/infrastructure",
|
||||
"health": "/health",
|
||||
"health_full": "/health/full"
|
||||
|
||||
@@ -0,0 +1,744 @@
|
||||
"""
|
||||
Housekeeping Controller
|
||||
|
||||
Provides API endpoints for home automation via Home Assistant.
|
||||
Designed for the Tatlock Housekeeper agent and other consumers.
|
||||
"""
|
||||
from fastapi import APIRouter, HTTPException, Query, Depends
|
||||
from typing import List, Dict, Any, Optional
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from src.controllers.base import BaseController
|
||||
from src.clients.homeassistant_client import get_homeassistant_client
|
||||
from src.logging_config import get_logger
|
||||
from src.auth.oidc import get_admin_user
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
|
||||
# ========================================================================
|
||||
# Pydantic Schemas
|
||||
# ========================================================================
|
||||
|
||||
class Device(BaseModel):
|
||||
"""Device/entity information"""
|
||||
entity_id: str
|
||||
name: str
|
||||
domain: str
|
||||
area: Optional[str] = None
|
||||
state: str
|
||||
attributes: Dict[str, Any] = {}
|
||||
last_changed: Optional[str] = None
|
||||
|
||||
|
||||
class DeviceListResponse(BaseModel):
|
||||
"""Response for device listing"""
|
||||
devices: List[Device]
|
||||
|
||||
|
||||
class DeviceDetailResponse(Device):
|
||||
"""Detailed device response"""
|
||||
pass
|
||||
|
||||
|
||||
class Area(BaseModel):
|
||||
"""Area/room information"""
|
||||
id: str
|
||||
name: str
|
||||
|
||||
|
||||
class AreaListResponse(BaseModel):
|
||||
"""Response for area listing"""
|
||||
areas: List[Area]
|
||||
|
||||
|
||||
class DeviceControlRequest(BaseModel):
|
||||
"""Request to control a device"""
|
||||
action: str = Field(..., description="Action: turn_on, turn_off, or toggle")
|
||||
brightness: Optional[int] = Field(None, ge=0, le=255)
|
||||
color_temp: Optional[int] = None
|
||||
rgb_color: Optional[List[int]] = None
|
||||
|
||||
class Config:
|
||||
extra = "allow" # Allow additional attributes
|
||||
|
||||
|
||||
class DeviceControlResponse(BaseModel):
|
||||
"""Response from device control"""
|
||||
success: bool
|
||||
entity_id: str
|
||||
new_state: Optional[str] = None
|
||||
message: str
|
||||
|
||||
|
||||
class Scene(BaseModel):
|
||||
"""Scene information"""
|
||||
id: str
|
||||
name: str
|
||||
|
||||
|
||||
class SceneListResponse(BaseModel):
|
||||
"""Response for scene listing"""
|
||||
scenes: List[Scene]
|
||||
|
||||
|
||||
class SceneActivateResponse(BaseModel):
|
||||
"""Response from scene activation"""
|
||||
success: bool
|
||||
scene_id: str
|
||||
message: str
|
||||
|
||||
|
||||
class Script(BaseModel):
|
||||
"""Script information"""
|
||||
id: str
|
||||
name: str
|
||||
|
||||
|
||||
class ScriptListResponse(BaseModel):
|
||||
"""Response for script listing"""
|
||||
scripts: List[Script]
|
||||
|
||||
|
||||
class ScriptRunRequest(BaseModel):
|
||||
"""Request to run a script"""
|
||||
variables: Optional[Dict[str, Any]] = None
|
||||
|
||||
|
||||
class ScriptRunResponse(BaseModel):
|
||||
"""Response from script execution"""
|
||||
success: bool
|
||||
script_id: str
|
||||
message: str
|
||||
|
||||
|
||||
class Automation(BaseModel):
|
||||
"""Automation information"""
|
||||
id: str
|
||||
name: str
|
||||
enabled: bool
|
||||
|
||||
|
||||
class AutomationListResponse(BaseModel):
|
||||
"""Response for automation listing"""
|
||||
automations: List[Automation]
|
||||
|
||||
|
||||
class AutomationToggleRequest(BaseModel):
|
||||
"""Request to toggle automation"""
|
||||
enabled: bool
|
||||
|
||||
|
||||
class AutomationToggleResponse(BaseModel):
|
||||
"""Response from automation toggle"""
|
||||
success: bool
|
||||
automation_id: str
|
||||
enabled: bool
|
||||
message: str
|
||||
|
||||
|
||||
class HistoryEntry(BaseModel):
|
||||
"""Single history entry"""
|
||||
state: str
|
||||
timestamp: str
|
||||
attributes: Dict[str, Any] = {}
|
||||
|
||||
|
||||
class HistoryResponse(BaseModel):
|
||||
"""Response for history query"""
|
||||
entity_id: str
|
||||
history: List[HistoryEntry]
|
||||
|
||||
|
||||
class HealthResponse(BaseModel):
|
||||
"""Health check response"""
|
||||
status: str
|
||||
connected: bool
|
||||
platform: str
|
||||
version: Optional[str] = None
|
||||
error: Optional[str] = None
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
"""Standard error response"""
|
||||
error: bool = True
|
||||
code: str
|
||||
message: str
|
||||
|
||||
|
||||
# ========================================================================
|
||||
# Controller
|
||||
# ========================================================================
|
||||
|
||||
class HousekeepingController(BaseController):
|
||||
"""
|
||||
Controller for home automation operations
|
||||
|
||||
Provides endpoints for:
|
||||
- Device discovery and control
|
||||
- Scene activation
|
||||
- Script execution
|
||||
- Automation management
|
||||
- State history
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
super().__init__(prefix="/housekeeping", tags=["Housekeeping"])
|
||||
|
||||
def create_router(self) -> APIRouter:
|
||||
"""Create and configure the router"""
|
||||
router = APIRouter(prefix=self.prefix, tags=self.tags)
|
||||
|
||||
# ====================================================================
|
||||
# Health
|
||||
# ====================================================================
|
||||
|
||||
@router.get(
|
||||
"/health",
|
||||
response_model=HealthResponse,
|
||||
summary="Home automation health check"
|
||||
)
|
||||
async def get_health():
|
||||
"""
|
||||
Check Home Assistant connection health
|
||||
|
||||
Returns connection status and HA version.
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
return await ha.health_check()
|
||||
|
||||
# ====================================================================
|
||||
# Device Discovery
|
||||
# ====================================================================
|
||||
|
||||
@router.get(
|
||||
"/devices",
|
||||
response_model=DeviceListResponse,
|
||||
summary="List available devices"
|
||||
)
|
||||
async def list_devices(
|
||||
domain: Optional[str] = Query(None, description="Filter by domain (light, switch, climate, etc.)"),
|
||||
area: Optional[str] = Query(None, description="Filter by area/room name")
|
||||
):
|
||||
"""
|
||||
List all available devices with optional filtering
|
||||
|
||||
Query Parameters:
|
||||
- domain: Filter by device type (light, switch, climate, media_player, etc.)
|
||||
- area: Filter by area/room name
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
states = await ha.get_states()
|
||||
|
||||
# Non-controllable domains to filter out
|
||||
excluded_domains = {
|
||||
"zone", "person", "device_tracker", "sun", "weather",
|
||||
"persistent_notification", "update", "binary_sensor", "sensor",
|
||||
"conversation", "calendar", "button", "number", "select",
|
||||
"text", "time", "date", "datetime", "image", "tts", "stt"
|
||||
}
|
||||
|
||||
devices = []
|
||||
for state in states:
|
||||
entity_id = state.get("entity_id", "")
|
||||
entity_domain = entity_id.split(".")[0] if "." in entity_id else ""
|
||||
|
||||
# Skip non-controllable entities
|
||||
if entity_domain in excluded_domains:
|
||||
continue
|
||||
|
||||
# Apply domain filter
|
||||
if domain and entity_domain != domain:
|
||||
continue
|
||||
|
||||
# Get area from attributes
|
||||
device_area = state.get("attributes", {}).get("area_id")
|
||||
|
||||
# Apply area filter
|
||||
if area and device_area and area.lower() not in device_area.lower():
|
||||
continue
|
||||
|
||||
device = Device(
|
||||
entity_id=entity_id,
|
||||
name=state.get("attributes", {}).get("friendly_name", entity_id),
|
||||
domain=entity_domain,
|
||||
area=device_area,
|
||||
state=state.get("state", "unknown"),
|
||||
attributes=state.get("attributes", {}),
|
||||
last_changed=state.get("last_changed")
|
||||
)
|
||||
devices.append(device)
|
||||
|
||||
return DeviceListResponse(devices=devices)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to list devices: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
@router.get(
|
||||
"/devices/{entity_id:path}",
|
||||
response_model=DeviceDetailResponse,
|
||||
responses={404: {"model": ErrorResponse}}
|
||||
)
|
||||
async def get_device(entity_id: str):
|
||||
"""
|
||||
Get detailed state of a specific device
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID (e.g., light.living_room)
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
state = await ha.get_state(entity_id)
|
||||
|
||||
if not state:
|
||||
raise HTTPException(
|
||||
status_code=404,
|
||||
detail={"error": True, "code": "DEVICE_NOT_FOUND",
|
||||
"message": f"Device {entity_id} not found"}
|
||||
)
|
||||
|
||||
entity_domain = entity_id.split(".")[0] if "." in entity_id else ""
|
||||
|
||||
return DeviceDetailResponse(
|
||||
entity_id=entity_id,
|
||||
name=state.get("attributes", {}).get("friendly_name", entity_id),
|
||||
domain=entity_domain,
|
||||
area=state.get("attributes", {}).get("area_id"),
|
||||
state=state.get("state", "unknown"),
|
||||
attributes=state.get("attributes", {}),
|
||||
last_changed=state.get("last_changed")
|
||||
)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to get device {entity_id}: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
@router.get(
|
||||
"/areas",
|
||||
response_model=AreaListResponse,
|
||||
summary="List areas/rooms"
|
||||
)
|
||||
async def list_areas():
|
||||
"""
|
||||
List all configured areas/rooms in Home Assistant
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
areas = await ha.get_areas()
|
||||
return AreaListResponse(
|
||||
areas=[Area(id=a["id"], name=a["name"]) for a in areas]
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to list areas: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
# ====================================================================
|
||||
# Device Control
|
||||
# ====================================================================
|
||||
|
||||
@router.post(
|
||||
"/devices/{entity_id:path}/control",
|
||||
response_model=DeviceControlResponse,
|
||||
responses={404: {"model": ErrorResponse}, 400: {"model": ErrorResponse}}
|
||||
)
|
||||
async def control_device(
|
||||
entity_id: str,
|
||||
request: DeviceControlRequest,
|
||||
user: Dict = Depends(get_admin_user)
|
||||
):
|
||||
"""
|
||||
Control a device (turn on, turn off, toggle, or set attributes)
|
||||
|
||||
Args:
|
||||
entity_id: Entity ID (e.g., light.living_room)
|
||||
request: Control request with action and optional attributes
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
# Validate action
|
||||
valid_actions = ["turn_on", "turn_off", "toggle"]
|
||||
if request.action not in valid_actions:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail={"error": True, "code": "INVALID_ACTION",
|
||||
"message": f"Invalid action '{request.action}'. Must be one of: {', '.join(valid_actions)}"}
|
||||
)
|
||||
|
||||
try:
|
||||
# Check device exists first
|
||||
current_state = await ha.get_state(entity_id)
|
||||
if not current_state:
|
||||
raise HTTPException(
|
||||
status_code=404,
|
||||
detail={"error": True, "code": "DEVICE_NOT_FOUND",
|
||||
"message": f"Device {entity_id} not found"}
|
||||
)
|
||||
|
||||
# Build attributes dict from request
|
||||
attributes = {}
|
||||
if request.brightness is not None:
|
||||
attributes["brightness"] = request.brightness
|
||||
if request.color_temp is not None:
|
||||
attributes["color_temp"] = request.color_temp
|
||||
if request.rgb_color is not None:
|
||||
attributes["rgb_color"] = request.rgb_color
|
||||
|
||||
# Add any extra attributes from request
|
||||
extra_fields = request.model_dump(exclude={"action", "brightness", "color_temp", "rgb_color"})
|
||||
for key, value in extra_fields.items():
|
||||
if value is not None:
|
||||
attributes[key] = value
|
||||
|
||||
# Execute action
|
||||
if request.action == "turn_on":
|
||||
await ha.turn_on(entity_id, **attributes)
|
||||
elif request.action == "turn_off":
|
||||
await ha.turn_off(entity_id)
|
||||
else: # toggle
|
||||
await ha.toggle(entity_id)
|
||||
|
||||
# Get new state
|
||||
new_state = await ha.get_state(entity_id)
|
||||
|
||||
logger.info(f"Device {entity_id} controlled: {request.action} by {user.get('preferred_username', 'unknown')}")
|
||||
|
||||
return DeviceControlResponse(
|
||||
success=True,
|
||||
entity_id=entity_id,
|
||||
new_state=new_state.get("state") if new_state else None,
|
||||
message=f"Device {request.action} successful"
|
||||
)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to control device {entity_id}: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
# ====================================================================
|
||||
# Scenes
|
||||
# ====================================================================
|
||||
|
||||
@router.get(
|
||||
"/scenes",
|
||||
response_model=SceneListResponse,
|
||||
summary="List available scenes"
|
||||
)
|
||||
async def list_scenes():
|
||||
"""
|
||||
List all available scenes in Home Assistant
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
states = await ha.get_states()
|
||||
|
||||
scenes = [
|
||||
Scene(
|
||||
id=s["entity_id"],
|
||||
name=s.get("attributes", {}).get("friendly_name", s["entity_id"])
|
||||
)
|
||||
for s in states
|
||||
if s["entity_id"].startswith("scene.")
|
||||
]
|
||||
|
||||
return SceneListResponse(scenes=scenes)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to list scenes: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
@router.post(
|
||||
"/scenes/{scene_id:path}/activate",
|
||||
response_model=SceneActivateResponse,
|
||||
responses={404: {"model": ErrorResponse}}
|
||||
)
|
||||
async def activate_scene(
|
||||
scene_id: str,
|
||||
user: Dict = Depends(get_admin_user)
|
||||
):
|
||||
"""
|
||||
Activate a scene
|
||||
|
||||
Args:
|
||||
scene_id: Scene entity ID (e.g., scene.movie_night)
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
# Verify scene exists
|
||||
state = await ha.get_state(scene_id)
|
||||
if not state:
|
||||
raise HTTPException(
|
||||
status_code=404,
|
||||
detail={"error": True, "code": "SCENE_NOT_FOUND",
|
||||
"message": f"Scene {scene_id} not found"}
|
||||
)
|
||||
|
||||
await ha.activate_scene(scene_id)
|
||||
|
||||
logger.info(f"Scene {scene_id} activated by {user.get('preferred_username', 'unknown')}")
|
||||
|
||||
return SceneActivateResponse(
|
||||
success=True,
|
||||
scene_id=scene_id,
|
||||
message="Scene activated"
|
||||
)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to activate scene {scene_id}: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
# ====================================================================
|
||||
# Scripts
|
||||
# ====================================================================
|
||||
|
||||
@router.get(
|
||||
"/scripts",
|
||||
response_model=ScriptListResponse,
|
||||
summary="List available scripts"
|
||||
)
|
||||
async def list_scripts():
|
||||
"""
|
||||
List all available scripts/sequences in Home Assistant
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
states = await ha.get_states()
|
||||
|
||||
scripts = [
|
||||
Script(
|
||||
id=s["entity_id"],
|
||||
name=s.get("attributes", {}).get("friendly_name", s["entity_id"])
|
||||
)
|
||||
for s in states
|
||||
if s["entity_id"].startswith("script.")
|
||||
]
|
||||
|
||||
return ScriptListResponse(scripts=scripts)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to list scripts: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
@router.post(
|
||||
"/scripts/{script_id:path}/run",
|
||||
response_model=ScriptRunResponse,
|
||||
responses={404: {"model": ErrorResponse}}
|
||||
)
|
||||
async def run_script(
|
||||
script_id: str,
|
||||
request: Optional[ScriptRunRequest] = None,
|
||||
user: Dict = Depends(get_admin_user)
|
||||
):
|
||||
"""
|
||||
Execute a script with optional variables
|
||||
|
||||
Args:
|
||||
script_id: Script entity ID (e.g., script.bedtime_routine)
|
||||
request: Optional variables for the script
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
# Verify script exists
|
||||
state = await ha.get_state(script_id)
|
||||
if not state:
|
||||
raise HTTPException(
|
||||
status_code=404,
|
||||
detail={"error": True, "code": "SCRIPT_NOT_FOUND",
|
||||
"message": f"Script {script_id} not found"}
|
||||
)
|
||||
|
||||
variables = request.variables if request else None
|
||||
await ha.run_script(script_id, variables)
|
||||
|
||||
logger.info(f"Script {script_id} executed by {user.get('preferred_username', 'unknown')}")
|
||||
|
||||
return ScriptRunResponse(
|
||||
success=True,
|
||||
script_id=script_id,
|
||||
message="Script executed"
|
||||
)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to run script {script_id}: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
# ====================================================================
|
||||
# Automations
|
||||
# ====================================================================
|
||||
|
||||
@router.get(
|
||||
"/automations",
|
||||
response_model=AutomationListResponse,
|
||||
summary="List automations"
|
||||
)
|
||||
async def list_automations():
|
||||
"""
|
||||
List all automations with their enabled/disabled status
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
states = await ha.get_states()
|
||||
|
||||
automations = [
|
||||
Automation(
|
||||
id=s["entity_id"],
|
||||
name=s.get("attributes", {}).get("friendly_name", s["entity_id"]),
|
||||
enabled=s.get("state") == "on"
|
||||
)
|
||||
for s in states
|
||||
if s["entity_id"].startswith("automation.")
|
||||
]
|
||||
|
||||
return AutomationListResponse(automations=automations)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to list automations: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
@router.post(
|
||||
"/automations/{automation_id:path}/toggle",
|
||||
response_model=AutomationToggleResponse,
|
||||
responses={404: {"model": ErrorResponse}}
|
||||
)
|
||||
async def toggle_automation(
|
||||
automation_id: str,
|
||||
request: AutomationToggleRequest,
|
||||
user: Dict = Depends(get_admin_user)
|
||||
):
|
||||
"""
|
||||
Enable or disable an automation
|
||||
|
||||
Args:
|
||||
automation_id: Automation entity ID (e.g., automation.motion_lights)
|
||||
request: Contains enabled boolean
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
# Verify automation exists
|
||||
state = await ha.get_state(automation_id)
|
||||
if not state:
|
||||
raise HTTPException(
|
||||
status_code=404,
|
||||
detail={"error": True, "code": "AUTOMATION_NOT_FOUND",
|
||||
"message": f"Automation {automation_id} not found"}
|
||||
)
|
||||
|
||||
if request.enabled:
|
||||
await ha.enable_automation(automation_id)
|
||||
else:
|
||||
await ha.disable_automation(automation_id)
|
||||
|
||||
logger.info(f"Automation {automation_id} {'enabled' if request.enabled else 'disabled'} by {user.get('preferred_username', 'unknown')}")
|
||||
|
||||
return AutomationToggleResponse(
|
||||
success=True,
|
||||
automation_id=automation_id,
|
||||
enabled=request.enabled,
|
||||
message=f"Automation {'enabled' if request.enabled else 'disabled'}"
|
||||
)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to toggle automation {automation_id}: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
# ====================================================================
|
||||
# History
|
||||
# ====================================================================
|
||||
|
||||
@router.get(
|
||||
"/history",
|
||||
response_model=HistoryResponse,
|
||||
responses={400: {"model": ErrorResponse}}
|
||||
)
|
||||
async def get_history(
|
||||
entity_id: str = Query(..., description="Entity ID to get history for"),
|
||||
hours: int = Query(24, ge=1, le=168, description="Hours of history (1-168)")
|
||||
):
|
||||
"""
|
||||
Get state history for a device
|
||||
|
||||
Query Parameters:
|
||||
- entity_id: Device entity ID (required)
|
||||
- hours: Number of hours of history (default 24, max 168/1 week)
|
||||
"""
|
||||
ha = get_homeassistant_client()
|
||||
|
||||
try:
|
||||
history_data = await ha.get_history(entity_id, hours)
|
||||
|
||||
# Transform HA history format to our format
|
||||
history_entries = []
|
||||
if history_data and len(history_data) > 0:
|
||||
for entry in history_data[0]: # First array is our entity
|
||||
history_entries.append(HistoryEntry(
|
||||
state=entry.get("state", "unknown"),
|
||||
timestamp=entry.get("last_changed", ""),
|
||||
attributes=entry.get("attributes", {})
|
||||
))
|
||||
|
||||
return HistoryResponse(
|
||||
entity_id=entity_id,
|
||||
history=history_entries
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to get history for {entity_id}: {e}")
|
||||
raise HTTPException(
|
||||
status_code=500,
|
||||
detail={"error": True, "code": "CONNECTION_ERROR", "message": str(e)}
|
||||
)
|
||||
|
||||
return router
|
||||
|
||||
|
||||
# Create controller instance
|
||||
housekeeping_controller = HousekeepingController()
|
||||
@@ -2,16 +2,12 @@
|
||||
Tools Controller
|
||||
|
||||
Provides utility tool endpoints including:
|
||||
- Web scraping and content extraction
|
||||
- DNS lookups
|
||||
"""
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
|
||||
from src.controllers.base import BaseController
|
||||
from src.logging_config import get_logger
|
||||
from src.web_scraper.schemas import WebScraperRequest, WebScraperResponse
|
||||
from src.web_scraper.service import WebScraperService
|
||||
from src.web_scraper.exceptions import FetchError, ScrapingError
|
||||
from src.dns.schemas import DNSLookupRequest, DNSLookupResponse
|
||||
from src.dns.service import DNSService
|
||||
from src.dns.exceptions import DNSQueryError
|
||||
@@ -24,79 +20,17 @@ class ToolsController(BaseController):
|
||||
Controller for utility tools
|
||||
|
||||
Provides endpoints for:
|
||||
- Web scraping and content extraction
|
||||
- DNS lookups
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
super().__init__(prefix="/tools", tags=["Tools"])
|
||||
# Initialize services (could be dependency injected for testing)
|
||||
self.scraper_service = WebScraperService()
|
||||
self.dns_service = DNSService()
|
||||
|
||||
def create_router(self) -> APIRouter:
|
||||
"""Create and configure the router"""
|
||||
router = APIRouter(prefix=self.prefix, tags=self.tags)
|
||||
|
||||
@router.post(
|
||||
"/scrape",
|
||||
response_model=WebScraperResponse,
|
||||
status_code=status.HTTP_200_OK,
|
||||
summary="Scrape website content",
|
||||
description="""
|
||||
Scrape and extract main content from a website.
|
||||
|
||||
Uses trafilatura for intelligent content extraction (articles, blog posts, documentation),
|
||||
with BeautifulSoup as fallback. Perfect for feeding webpage content to LLMs.
|
||||
|
||||
**Features:**
|
||||
- Intelligent main content extraction
|
||||
- Removes navigation, ads, footers
|
||||
- Optional link extraction
|
||||
- Configurable content length limits
|
||||
|
||||
**Rate Limiting:** None (internal network use only)
|
||||
"""
|
||||
)
|
||||
async def scrape_website(request: WebScraperRequest) -> WebScraperResponse:
|
||||
"""
|
||||
Scrape a website and extract its main content
|
||||
|
||||
Args:
|
||||
request: Scraping request with URL and options
|
||||
|
||||
Returns:
|
||||
Extracted content with metadata
|
||||
|
||||
Raises:
|
||||
HTTPException: 400 for fetch errors, 500 for processing errors
|
||||
"""
|
||||
try:
|
||||
logger.info(f"Received scrape request for: {request.url}")
|
||||
result = await self.scraper_service.scrape_url(request)
|
||||
return result
|
||||
|
||||
except FetchError as e:
|
||||
logger.warning(f"Fetch failed: {str(e)}")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=f"Failed to fetch URL: {str(e)}"
|
||||
)
|
||||
|
||||
except ScrapingError as e:
|
||||
logger.error(f"Scraping failed: {str(e)}")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
detail=f"Failed to extract content: {str(e)}"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Unexpected error: {str(e)}", exc_info=True)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
detail="An unexpected error occurred"
|
||||
)
|
||||
|
||||
@router.post(
|
||||
"/dns/lookup",
|
||||
response_model=DNSLookupResponse,
|
||||
|
||||
@@ -17,3 +17,7 @@ PORTAINER_API_KEY = "ptr_your_api_token_here" # Create in Portainer UI: User me
|
||||
NPM_URL = "http://localhost:81"
|
||||
NPM_EMAIL = "admin@example.com"
|
||||
NPM_PASSWORD = "your_password_here"
|
||||
|
||||
# Home Assistant Configuration
|
||||
HOMEASSISTANT_URL = "http://192.168.86.149:8123" # Or http://home-assistant:8123 in Docker
|
||||
HOMEASSISTANT_TOKEN = "your_long_lived_access_token_here" # Create in HA: Profile → Long-Lived Access Tokens
|
||||
|
||||
+22
-1
@@ -14,6 +14,7 @@ from src.controllers.tools_controller import tools_controller
|
||||
from src.controllers.health_controller import health_controller
|
||||
from src.controllers.static_controller import static_controller
|
||||
from src.controllers.ai_controller import router as ai_router
|
||||
from src.controllers.housekeeping_controller import housekeeping_controller
|
||||
from src.security import initialize_oidc
|
||||
|
||||
# Initialize settings
|
||||
@@ -100,6 +101,25 @@ app = FastAPI(
|
||||
|
||||
Automates infrastructure operations via Portainer and Nginx Proxy Manager APIs.
|
||||
|
||||
### Home Automation (Housekeeping)
|
||||
**Read Endpoints:**
|
||||
- `GET /housekeeping/health` - Check Home Assistant connectivity
|
||||
- `GET /housekeeping/devices` - List devices (filter by domain, area)
|
||||
- `GET /housekeeping/devices/{entity_id}` - Get device details
|
||||
- `GET /housekeeping/areas` - List areas/rooms
|
||||
- `GET /housekeeping/scenes` - List scenes
|
||||
- `GET /housekeeping/scripts` - List scripts
|
||||
- `GET /housekeeping/automations` - List automations
|
||||
- `GET /housekeeping/history` - Get state history
|
||||
|
||||
**Write Endpoints (Admin Only):**
|
||||
- `POST /housekeeping/devices/{entity_id}/control` - Control device
|
||||
- `POST /housekeeping/scenes/{scene_id}/activate` - Activate scene
|
||||
- `POST /housekeeping/scripts/{script_id}/run` - Run script
|
||||
- `POST /housekeeping/automations/{automation_id}/toggle` - Enable/disable automation
|
||||
|
||||
Abstracts Home Assistant for the Tatlock Housekeeper agent and other consumers.
|
||||
|
||||
### Web Scraper
|
||||
Intelligent web scraping with main content extraction.
|
||||
Perfect for extracting articles, documentation, and blog posts for LLM consumption.
|
||||
@@ -148,8 +168,9 @@ app.add_middleware(
|
||||
|
||||
# Include controller routers
|
||||
app.include_router(health_controller.router) # / and /health
|
||||
app.include_router(tools_controller.router) # /web-scraper/scrape
|
||||
app.include_router(tools_controller.router) # /tools/*
|
||||
app.include_router(infrastructure_controller.router) # /infrastructure/*
|
||||
app.include_router(housekeeping_controller.router) # /housekeeping/*
|
||||
app.include_router(static_controller.router) # /static/*
|
||||
app.include_router(ai_router) # /ai/*
|
||||
|
||||
|
||||
@@ -1,13 +0,0 @@
|
||||
"""
|
||||
Web scraper module for extracting content from websites
|
||||
"""
|
||||
from src.web_scraper.router import router
|
||||
from src.web_scraper.schemas import WebScraperRequest, WebScraperResponse
|
||||
from src.web_scraper.service import WebScraperService
|
||||
|
||||
__all__ = [
|
||||
"router",
|
||||
"WebScraperRequest",
|
||||
"WebScraperResponse",
|
||||
"WebScraperService",
|
||||
]
|
||||
@@ -1,32 +0,0 @@
|
||||
"""
|
||||
Configuration for web scraper module
|
||||
"""
|
||||
from pydantic_settings import BaseSettings
|
||||
from functools import lru_cache
|
||||
|
||||
|
||||
class WebScraperSettings(BaseSettings):
|
||||
"""Web scraper specific settings"""
|
||||
|
||||
# HTTP client configuration
|
||||
request_timeout: int = 30
|
||||
max_redirects: int = 5
|
||||
user_agent: str = "Mozilla/5.0 (compatible; CoreCode/1.0)"
|
||||
|
||||
# Content extraction
|
||||
default_max_length: int = 10000
|
||||
max_links_to_extract: int = 50
|
||||
|
||||
# Rate limiting (future use)
|
||||
rate_limit_enabled: bool = False
|
||||
requests_per_minute: int = 60
|
||||
|
||||
class Config:
|
||||
env_prefix = "WEB_SCRAPER_"
|
||||
case_sensitive = False
|
||||
|
||||
|
||||
@lru_cache()
|
||||
def get_web_scraper_settings() -> WebScraperSettings:
|
||||
"""Cached web scraper settings instance"""
|
||||
return WebScraperSettings()
|
||||
@@ -1,18 +0,0 @@
|
||||
"""
|
||||
Custom exceptions for web scraper module
|
||||
"""
|
||||
|
||||
|
||||
class WebScraperException(Exception):
|
||||
"""Base exception for web scraper module"""
|
||||
pass
|
||||
|
||||
|
||||
class FetchError(WebScraperException):
|
||||
"""Raised when URL fetch fails"""
|
||||
pass
|
||||
|
||||
|
||||
class ScrapingError(WebScraperException):
|
||||
"""Raised when content extraction fails"""
|
||||
pass
|
||||
@@ -1,79 +0,0 @@
|
||||
"""
|
||||
API routes for web scraper module
|
||||
"""
|
||||
from fastapi import APIRouter, HTTPException, status
|
||||
|
||||
from src.logging_config import get_logger
|
||||
from src.web_scraper.schemas import WebScraperRequest, WebScraperResponse
|
||||
from src.web_scraper.service import WebScraperService
|
||||
from src.web_scraper.exceptions import FetchError, ScrapingError
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
router = APIRouter(
|
||||
prefix="/web-scraper",
|
||||
tags=["Web Scraper"]
|
||||
)
|
||||
|
||||
# Initialize service (could be dependency injected for testing)
|
||||
scraper_service = WebScraperService()
|
||||
|
||||
|
||||
@router.post(
|
||||
"/scrape",
|
||||
response_model=WebScraperResponse,
|
||||
status_code=status.HTTP_200_OK,
|
||||
summary="Scrape website content",
|
||||
description="""
|
||||
Scrape and extract main content from a website.
|
||||
|
||||
Uses trafilatura for intelligent content extraction (articles, blog posts, documentation),
|
||||
with BeautifulSoup as fallback. Perfect for feeding webpage content to LLMs.
|
||||
|
||||
**Features:**
|
||||
- Intelligent main content extraction
|
||||
- Removes navigation, ads, footers
|
||||
- Optional link extraction
|
||||
- Configurable content length limits
|
||||
|
||||
**Rate Limiting:** None (internal network use only)
|
||||
"""
|
||||
)
|
||||
async def scrape_website(request: WebScraperRequest) -> WebScraperResponse:
|
||||
"""
|
||||
Scrape a website and extract its main content
|
||||
|
||||
Args:
|
||||
request: Scraping request with URL and options
|
||||
|
||||
Returns:
|
||||
Extracted content with metadata
|
||||
|
||||
Raises:
|
||||
HTTPException: 400 for fetch errors, 500 for processing errors
|
||||
"""
|
||||
try:
|
||||
logger.info(f"Received scrape request for: {request.url}")
|
||||
result = await scraper_service.scrape_url(request)
|
||||
return result
|
||||
|
||||
except FetchError as e:
|
||||
logger.warning(f"Fetch failed: {str(e)}")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_400_BAD_REQUEST,
|
||||
detail=f"Failed to fetch URL: {str(e)}"
|
||||
)
|
||||
|
||||
except ScrapingError as e:
|
||||
logger.error(f"Scraping failed: {str(e)}")
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
detail=f"Failed to extract content: {str(e)}"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Unexpected error: {str(e)}", exc_info=True)
|
||||
raise HTTPException(
|
||||
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
detail="An unexpected error occurred"
|
||||
)
|
||||
@@ -1,69 +0,0 @@
|
||||
"""
|
||||
Pydantic schemas for web scraper module
|
||||
"""
|
||||
from pydantic import HttpUrl, Field
|
||||
from typing import Optional
|
||||
from datetime import datetime
|
||||
from src.base_schema import BaseSchema
|
||||
|
||||
|
||||
class WebScraperRequest(BaseSchema):
|
||||
"""Request model for web scraping"""
|
||||
|
||||
url: HttpUrl = Field(
|
||||
...,
|
||||
description="The URL to scrape",
|
||||
examples=["https://example.com/article"]
|
||||
)
|
||||
|
||||
extract_main_content: bool = Field(
|
||||
default=True,
|
||||
description="Use intelligent content extraction (trafilatura) vs raw HTML parsing"
|
||||
)
|
||||
|
||||
include_links: bool = Field(
|
||||
default=False,
|
||||
description="Include list of links found on the page"
|
||||
)
|
||||
|
||||
max_length: Optional[int] = Field(
|
||||
default=10000,
|
||||
ge=100,
|
||||
le=100000,
|
||||
description="Maximum content length to return (100-100000 chars)"
|
||||
)
|
||||
|
||||
|
||||
class WebScraperResponse(BaseSchema):
|
||||
"""Response model for web scraping"""
|
||||
|
||||
url: str = Field(
|
||||
...,
|
||||
description="The scraped URL"
|
||||
)
|
||||
|
||||
title: Optional[str] = Field(
|
||||
default=None,
|
||||
description="Page title extracted from <title> tag"
|
||||
)
|
||||
|
||||
content: str = Field(
|
||||
...,
|
||||
description="Extracted page content"
|
||||
)
|
||||
|
||||
extracted_at: datetime = Field(
|
||||
...,
|
||||
description="UTC timestamp when content was extracted"
|
||||
)
|
||||
|
||||
content_length: int = Field(
|
||||
...,
|
||||
ge=0,
|
||||
description="Length of extracted content in characters"
|
||||
)
|
||||
|
||||
links: Optional[list[str]] = Field(
|
||||
default=None,
|
||||
description="List of HTTP(S) links found on the page (max 50)"
|
||||
)
|
||||
@@ -1,213 +0,0 @@
|
||||
"""
|
||||
Business logic for web scraper module
|
||||
"""
|
||||
import httpx
|
||||
from bs4 import BeautifulSoup
|
||||
import trafilatura
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional
|
||||
|
||||
from src.logging_config import get_logger
|
||||
from src.web_scraper.config import get_web_scraper_settings
|
||||
from src.web_scraper.schemas import WebScraperRequest, WebScraperResponse
|
||||
from src.web_scraper.exceptions import ScrapingError, FetchError
|
||||
|
||||
logger = get_logger(__name__)
|
||||
|
||||
|
||||
class WebScraperService:
|
||||
"""Service class for web scraping operations"""
|
||||
|
||||
def __init__(self):
|
||||
self.settings = get_web_scraper_settings()
|
||||
|
||||
async def scrape_url(self, request: WebScraperRequest) -> WebScraperResponse:
|
||||
"""
|
||||
Scrape and extract content from a URL
|
||||
|
||||
Args:
|
||||
request: Scraping request parameters
|
||||
|
||||
Returns:
|
||||
Extracted content with metadata
|
||||
|
||||
Raises:
|
||||
FetchError: If URL cannot be fetched
|
||||
ScrapingError: If content extraction fails
|
||||
"""
|
||||
url_str = str(request.url)
|
||||
logger.info(f"Starting scrape for URL: {url_str}")
|
||||
|
||||
try:
|
||||
# Fetch the webpage
|
||||
html_content = await self._fetch_url(url_str)
|
||||
|
||||
# Extract content based on settings
|
||||
if request.extract_main_content:
|
||||
content = self._extract_main_content(html_content, request.include_links)
|
||||
else:
|
||||
content = self._extract_basic_content(html_content)
|
||||
|
||||
# Extract metadata
|
||||
title = self._extract_title(html_content)
|
||||
links = self._extract_links(html_content) if request.include_links else None
|
||||
|
||||
# Clean and truncate content
|
||||
content = self._clean_content(content)
|
||||
if request.max_length and len(content) > request.max_length:
|
||||
content = content[:request.max_length] + "\n\n[Content truncated...]"
|
||||
logger.debug(f"Content truncated to {request.max_length} characters")
|
||||
|
||||
logger.info(f"Successfully scraped {len(content)} characters from {url_str}")
|
||||
|
||||
return WebScraperResponse(
|
||||
url=url_str,
|
||||
title=title,
|
||||
content=content,
|
||||
extracted_at=datetime.now(timezone.utc),
|
||||
content_length=len(content),
|
||||
links=links
|
||||
)
|
||||
|
||||
except FetchError:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Scraping failed for {url_str}: {str(e)}", exc_info=True)
|
||||
raise ScrapingError(f"Failed to scrape content: {str(e)}")
|
||||
|
||||
async def _fetch_url(self, url: str) -> str:
|
||||
"""
|
||||
Fetch HTML content from URL
|
||||
|
||||
Args:
|
||||
url: URL to fetch
|
||||
|
||||
Returns:
|
||||
HTML content as string
|
||||
|
||||
Raises:
|
||||
FetchError: If fetch fails
|
||||
"""
|
||||
try:
|
||||
async with httpx.AsyncClient(
|
||||
timeout=self.settings.request_timeout,
|
||||
follow_redirects=True,
|
||||
max_redirects=self.settings.max_redirects
|
||||
) as client:
|
||||
logger.debug(f"Fetching URL: {url}")
|
||||
response = await client.get(
|
||||
url,
|
||||
headers={"User-Agent": self.settings.user_agent}
|
||||
)
|
||||
response.raise_for_status()
|
||||
logger.debug(f"Fetched {len(response.text)} bytes from {url}")
|
||||
return response.text
|
||||
|
||||
except httpx.HTTPStatusError as e:
|
||||
logger.error(f"HTTP error {e.response.status_code} for {url}")
|
||||
raise FetchError(f"HTTP {e.response.status_code}: {e.response.reason_phrase}")
|
||||
except httpx.RequestError as e:
|
||||
logger.error(f"Request error for {url}: {str(e)}")
|
||||
raise FetchError(f"Failed to fetch URL: {str(e)}")
|
||||
|
||||
def _extract_main_content(self, html: str, include_links: bool = False) -> str:
|
||||
"""
|
||||
Extract main content using trafilatura (intelligent extraction)
|
||||
|
||||
Args:
|
||||
html: Raw HTML content
|
||||
include_links: Whether to preserve links in output
|
||||
|
||||
Returns:
|
||||
Extracted content
|
||||
"""
|
||||
logger.debug("Extracting main content with trafilatura")
|
||||
content = trafilatura.extract(
|
||||
html,
|
||||
include_links=include_links,
|
||||
include_images=False,
|
||||
output_format='txt',
|
||||
no_fallback=False
|
||||
)
|
||||
|
||||
# Fallback to BeautifulSoup if trafilatura fails
|
||||
if not content:
|
||||
logger.debug("Trafilatura extraction failed, falling back to BeautifulSoup")
|
||||
content = self._extract_basic_content(html)
|
||||
|
||||
return content
|
||||
|
||||
def _extract_basic_content(self, html: str) -> str:
|
||||
"""
|
||||
Extract content using basic BeautifulSoup parsing
|
||||
|
||||
Args:
|
||||
html: Raw HTML content
|
||||
|
||||
Returns:
|
||||
Extracted text content
|
||||
"""
|
||||
logger.debug("Extracting content with BeautifulSoup")
|
||||
soup = BeautifulSoup(html, 'html.parser')
|
||||
|
||||
# Remove unwanted elements
|
||||
for element in soup(["script", "style", "nav", "footer", "header", "aside"]):
|
||||
element.decompose()
|
||||
|
||||
# Extract text
|
||||
text = soup.get_text(separator='\n', strip=True)
|
||||
return text
|
||||
|
||||
def _extract_title(self, html: str) -> Optional[str]:
|
||||
"""
|
||||
Extract page title from HTML
|
||||
|
||||
Args:
|
||||
html: Raw HTML content
|
||||
|
||||
Returns:
|
||||
Page title or None
|
||||
"""
|
||||
soup = BeautifulSoup(html, 'html.parser')
|
||||
title = soup.title.string if soup.title else None
|
||||
if title:
|
||||
title = title.strip()
|
||||
logger.debug(f"Extracted title: {title}")
|
||||
return title
|
||||
|
||||
def _extract_links(self, html: str) -> list[str]:
|
||||
"""
|
||||
Extract HTTP(S) links from HTML
|
||||
|
||||
Args:
|
||||
html: Raw HTML content
|
||||
|
||||
Returns:
|
||||
List of absolute HTTP(S) URLs
|
||||
"""
|
||||
soup = BeautifulSoup(html, 'html.parser')
|
||||
links = [
|
||||
a.get('href')
|
||||
for a in soup.find_all('a', href=True)
|
||||
if a.get('href', '').startswith('http')
|
||||
]
|
||||
|
||||
# Limit number of links
|
||||
links = links[:self.settings.max_links_to_extract]
|
||||
logger.debug(f"Extracted {len(links)} links")
|
||||
return links
|
||||
|
||||
def _clean_content(self, content: str) -> str:
|
||||
"""
|
||||
Clean and normalize extracted content
|
||||
|
||||
Args:
|
||||
content: Raw extracted content
|
||||
|
||||
Returns:
|
||||
Cleaned content
|
||||
"""
|
||||
# Remove empty lines and normalize whitespace
|
||||
lines = [line.strip() for line in content.split('\n') if line.strip()]
|
||||
cleaned = '\n'.join(lines)
|
||||
return cleaned
|
||||
@@ -0,0 +1,300 @@
|
||||
"""Tests for Core-AI client."""
|
||||
import pytest
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
import httpx
|
||||
|
||||
from src.clients.ai_client import CoreAIClient, get_ai_client
|
||||
|
||||
|
||||
class TestCoreAIClientInit:
|
||||
"""Test CoreAIClient initialization."""
|
||||
|
||||
@patch("src.clients.ai_client.settings")
|
||||
def test_uses_settings_defaults(self, mock_settings):
|
||||
"""Client should use settings for defaults."""
|
||||
mock_settings.core_ai_base_url = "http://core-ai:8086"
|
||||
|
||||
client = CoreAIClient()
|
||||
|
||||
assert client.base_url == "http://core-ai:8086"
|
||||
assert client.timeout == 10
|
||||
|
||||
def test_accepts_custom_url(self):
|
||||
"""Client should accept custom URL."""
|
||||
client = CoreAIClient(base_url="http://custom:9000")
|
||||
|
||||
assert client.base_url == "http://custom:9000"
|
||||
|
||||
def test_accepts_custom_timeout(self):
|
||||
"""Client should accept custom timeout."""
|
||||
client = CoreAIClient(base_url="http://test:8086", timeout=30)
|
||||
|
||||
assert client.timeout == 30
|
||||
|
||||
def test_strips_trailing_slash_from_url(self):
|
||||
"""Client should strip trailing slash from URL."""
|
||||
client = CoreAIClient(base_url="http://core-ai:8086/")
|
||||
|
||||
assert client.base_url == "http://core-ai:8086"
|
||||
|
||||
def test_creates_http_client(self):
|
||||
"""Client should create httpx AsyncClient."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
assert client.client is not None
|
||||
|
||||
|
||||
class TestCoreAIClientClose:
|
||||
"""Test client close functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_close_closes_client(self):
|
||||
"""close should close the HTTP client."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
with patch.object(client.client, "aclose", new_callable=AsyncMock) as mock_close:
|
||||
await client.close()
|
||||
mock_close.assert_called_once()
|
||||
|
||||
|
||||
class TestCoreAIClientContextManager:
|
||||
"""Test async context manager."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_context_manager_enters(self):
|
||||
"""Context manager should return client on enter."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
with patch.object(client.client, "aclose", new_callable=AsyncMock):
|
||||
async with client as ctx:
|
||||
assert ctx is client
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_context_manager_closes_on_exit(self):
|
||||
"""Context manager should close client on exit."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
with patch.object(client, "close", new_callable=AsyncMock) as mock_close:
|
||||
async with client:
|
||||
pass
|
||||
mock_close.assert_called_once()
|
||||
|
||||
|
||||
class TestCoreAIClientHealthCheck:
|
||||
"""Test health check functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_true_on_200(self):
|
||||
"""Health check should return True when service responds 200."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_false_on_error(self):
|
||||
"""Health check should return False on connection error."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.side_effect = Exception("Connection refused")
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_false_on_non_200(self):
|
||||
"""Health check should return False on non-200 status."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 500
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestCoreAIClientGetMetrics:
|
||||
"""Test get metrics functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_metrics_returns_dict(self):
|
||||
"""get_metrics should return metrics dict."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
metrics_data = {
|
||||
"uptime_seconds": 3600,
|
||||
"agent": {"total_requests": 100},
|
||||
"tools": {"total_calls": 250}
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = metrics_data
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.get_metrics()
|
||||
|
||||
assert result == metrics_data
|
||||
assert result["uptime_seconds"] == 3600
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_metrics_raises_on_http_error(self):
|
||||
"""get_metrics should raise on HTTP error."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 500
|
||||
mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
|
||||
"Server Error", request=MagicMock(), response=mock_response
|
||||
)
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with pytest.raises(httpx.HTTPStatusError):
|
||||
await client.get_metrics()
|
||||
|
||||
|
||||
class TestCoreAIClientGetRecentErrors:
|
||||
"""Test get recent errors functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_recent_errors_returns_list(self):
|
||||
"""get_recent_errors should return list of errors."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
errors_data = {
|
||||
"errors": [
|
||||
{"timestamp": "2025-12-03T19:45:12Z", "error": "Timeout"},
|
||||
{"timestamp": "2025-12-03T19:46:00Z", "error": "Connection refused"}
|
||||
]
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = errors_data
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.get_recent_errors()
|
||||
|
||||
assert len(result) == 2
|
||||
assert result[0]["error"] == "Timeout"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_recent_errors_passes_limit(self):
|
||||
"""get_recent_errors should pass limit parameter."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"errors": []}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
await client.get_recent_errors(limit=5)
|
||||
|
||||
call_args = mock_get.call_args
|
||||
assert call_args[1]["params"]["limit"] == 5
|
||||
|
||||
|
||||
class TestCoreAIClientGetToolFailures:
|
||||
"""Test get tool failures functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_tool_failures_returns_list(self):
|
||||
"""get_tool_failures should return list of failures."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
failures_data = {
|
||||
"failures": [
|
||||
{"tool_name": "list_containers", "error": "Connection refused"}
|
||||
]
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = failures_data
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.get_tool_failures()
|
||||
|
||||
assert len(result) == 1
|
||||
assert result[0]["tool_name"] == "list_containers"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_tool_failures_passes_limit(self):
|
||||
"""get_tool_failures should pass limit parameter."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"failures": []}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
await client.get_tool_failures(limit=10)
|
||||
|
||||
call_args = mock_get.call_args
|
||||
assert call_args[1]["params"]["limit"] == 10
|
||||
|
||||
|
||||
class TestCoreAIClientResetMetrics:
|
||||
"""Test reset metrics functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_reset_metrics_returns_true_on_success(self):
|
||||
"""reset_metrics should return True on success."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.return_value = mock_response
|
||||
result = await client.reset_metrics()
|
||||
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_reset_metrics_raises_on_error(self):
|
||||
"""reset_metrics should raise on error."""
|
||||
client = CoreAIClient(base_url="http://test:8086")
|
||||
|
||||
with patch.object(client.client, "post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.side_effect = Exception("Connection refused")
|
||||
|
||||
with pytest.raises(Exception):
|
||||
await client.reset_metrics()
|
||||
|
||||
|
||||
class TestCoreAIClientSingleton:
|
||||
"""Test singleton pattern."""
|
||||
|
||||
def test_get_ai_client_returns_same_instance(self):
|
||||
"""get_ai_client should return singleton."""
|
||||
import src.clients.ai_client as module
|
||||
module._ai_client = None
|
||||
|
||||
client1 = get_ai_client()
|
||||
client2 = get_ai_client()
|
||||
|
||||
assert client1 is client2
|
||||
@@ -0,0 +1,264 @@
|
||||
"""Tests for AI controller."""
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
|
||||
from src.main import app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client():
|
||||
"""Create a test client."""
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_ai_client():
|
||||
"""Create a mock AI client."""
|
||||
mock = AsyncMock()
|
||||
return mock
|
||||
|
||||
|
||||
class TestAIHealth:
|
||||
"""Test /ai/health endpoint."""
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_health_returns_200(self, mock_get_client, client):
|
||||
"""AI health should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/health")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_health_returns_healthy_status(self, mock_get_client, client):
|
||||
"""AI health should return healthy status when service is up."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/health")
|
||||
data = response.json()
|
||||
|
||||
assert data["service"] == "core-ai"
|
||||
assert data["status"] == "healthy"
|
||||
assert data["accessible"] is True
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_health_returns_unhealthy_status(self, mock_get_client, client):
|
||||
"""AI health should return unhealthy status when service is down."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = False
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/health")
|
||||
data = response.json()
|
||||
|
||||
assert data["status"] == "unhealthy"
|
||||
assert data["accessible"] is False
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_health_handles_exception(self, mock_get_client, client):
|
||||
"""AI health should handle exceptions gracefully."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.side_effect = Exception("Connection refused")
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/health")
|
||||
data = response.json()
|
||||
|
||||
assert data["status"] == "error"
|
||||
assert data["accessible"] is False
|
||||
assert "error" in data
|
||||
|
||||
|
||||
class TestAIMetrics:
|
||||
"""Test /ai/metrics endpoint."""
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_metrics_returns_200(self, mock_get_client, client):
|
||||
"""AI metrics should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_metrics.return_value = {
|
||||
"uptime_seconds": 3600,
|
||||
"agent": {"total_requests": 100}
|
||||
}
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_metrics_returns_data(self, mock_get_client, client):
|
||||
"""AI metrics should return metrics data."""
|
||||
metrics_data = {
|
||||
"uptime_seconds": 3600,
|
||||
"agent": {"total_requests": 100},
|
||||
"tools": {"total_calls": 250}
|
||||
}
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_metrics.return_value = metrics_data
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics")
|
||||
data = response.json()
|
||||
|
||||
assert data["uptime_seconds"] == 3600
|
||||
assert data["agent"]["total_requests"] == 100
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_metrics_returns_503_on_error(self, mock_get_client, client):
|
||||
"""AI metrics should return 503 when service unavailable."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_metrics.side_effect = Exception("Service unavailable")
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics")
|
||||
assert response.status_code == 503
|
||||
|
||||
|
||||
class TestAIErrors:
|
||||
"""Test /ai/metrics/errors endpoint."""
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_errors_returns_200(self, mock_get_client, client):
|
||||
"""AI errors should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_recent_errors.return_value = []
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/errors")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_errors_returns_error_list(self, mock_get_client, client):
|
||||
"""AI errors should return list of errors."""
|
||||
errors = [
|
||||
{"timestamp": "2025-12-03T19:45:12Z", "error": "Timeout"},
|
||||
{"timestamp": "2025-12-03T19:46:00Z", "error": "Connection refused"}
|
||||
]
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_recent_errors.return_value = errors
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/errors")
|
||||
data = response.json()
|
||||
|
||||
assert "errors" in data
|
||||
assert "total" in data
|
||||
assert data["total"] == 2
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_errors_accepts_limit_parameter(self, mock_get_client, client):
|
||||
"""AI errors should accept limit parameter."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_recent_errors.return_value = []
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/errors?limit=5")
|
||||
assert response.status_code == 200
|
||||
mock_client.get_recent_errors.assert_called_with(limit=5)
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_errors_returns_503_on_error(self, mock_get_client, client):
|
||||
"""AI errors should return 503 when service unavailable."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_recent_errors.side_effect = Exception("Service unavailable")
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/errors")
|
||||
assert response.status_code == 503
|
||||
|
||||
|
||||
class TestAIToolFailures:
|
||||
"""Test /ai/metrics/tool-failures endpoint."""
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_tool_failures_returns_200(self, mock_get_client, client):
|
||||
"""Tool failures should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_tool_failures.return_value = []
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/tool-failures")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_tool_failures_returns_failure_list(self, mock_get_client, client):
|
||||
"""Tool failures should return list of failures."""
|
||||
failures = [
|
||||
{"tool_name": "list_containers", "error": "Connection refused"}
|
||||
]
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_tool_failures.return_value = failures
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/tool-failures")
|
||||
data = response.json()
|
||||
|
||||
assert "failures" in data
|
||||
assert "total" in data
|
||||
assert data["total"] == 1
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_tool_failures_accepts_limit_parameter(self, mock_get_client, client):
|
||||
"""Tool failures should accept limit parameter."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_tool_failures.return_value = []
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/tool-failures?limit=10")
|
||||
assert response.status_code == 200
|
||||
mock_client.get_tool_failures.assert_called_with(limit=10)
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_tool_failures_returns_503_on_error(self, mock_get_client, client):
|
||||
"""Tool failures should return 503 when service unavailable."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_tool_failures.side_effect = Exception("Service unavailable")
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.get("/ai/metrics/tool-failures")
|
||||
assert response.status_code == 503
|
||||
|
||||
|
||||
class TestAIMetricsReset:
|
||||
"""Test /ai/metrics/reset endpoint."""
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_reset_returns_200(self, mock_get_client, client):
|
||||
"""Reset metrics should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.reset_metrics.return_value = True
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.post("/ai/metrics/reset")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_reset_returns_success_message(self, mock_get_client, client):
|
||||
"""Reset metrics should return success message."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.reset_metrics.return_value = True
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.post("/ai/metrics/reset")
|
||||
data = response.json()
|
||||
|
||||
assert data["success"] is True
|
||||
assert "message" in data
|
||||
|
||||
@patch("src.controllers.ai_controller.get_ai_client")
|
||||
def test_reset_returns_503_on_error(self, mock_get_client, client):
|
||||
"""Reset metrics should return 503 when service unavailable."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.reset_metrics.side_effect = Exception("Service unavailable")
|
||||
mock_get_client.return_value = mock_client
|
||||
|
||||
response = client.post("/ai/metrics/reset")
|
||||
assert response.status_code == 503
|
||||
@@ -0,0 +1,331 @@
|
||||
"""Tests for DNS service."""
|
||||
import pytest
|
||||
from unittest.mock import patch, MagicMock
|
||||
import dns.resolver
|
||||
import dns.exception
|
||||
|
||||
from src.dns.service import DNSService
|
||||
from src.dns.schemas import DNSLookupRequest, DNSRecord
|
||||
from src.dns.exceptions import DNSQueryError
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def dns_service():
|
||||
"""Create a DNSService instance."""
|
||||
return DNSService()
|
||||
|
||||
|
||||
class TestDNSServiceInit:
|
||||
"""Test DNSService initialization."""
|
||||
|
||||
def test_service_has_resolver(self, dns_service):
|
||||
"""Service should have resolver configured."""
|
||||
assert dns_service.resolver is not None
|
||||
|
||||
def test_service_has_timeout(self, dns_service):
|
||||
"""Service should have timeout configured."""
|
||||
assert dns_service.resolver.timeout == 5.0
|
||||
assert dns_service.resolver.lifetime == 10.0
|
||||
|
||||
def test_supported_record_types(self, dns_service):
|
||||
"""Service should have supported record types."""
|
||||
assert "A" in dns_service.SUPPORTED_RECORD_TYPES
|
||||
assert "AAAA" in dns_service.SUPPORTED_RECORD_TYPES
|
||||
assert "MX" in dns_service.SUPPORTED_RECORD_TYPES
|
||||
assert "TXT" in dns_service.SUPPORTED_RECORD_TYPES
|
||||
assert "CNAME" in dns_service.SUPPORTED_RECORD_TYPES
|
||||
assert "NS" in dns_service.SUPPORTED_RECORD_TYPES
|
||||
|
||||
|
||||
class TestDNSServiceLookup:
|
||||
"""Test DNS lookup functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_validates_record_type(self, dns_service):
|
||||
"""lookup should raise error for unsupported record type."""
|
||||
request = DNSLookupRequest(domain="example.com", record_type="INVALID")
|
||||
|
||||
with pytest.raises(DNSQueryError) as exc_info:
|
||||
await dns_service.lookup(request)
|
||||
|
||||
assert "Unsupported record type" in str(exc_info.value)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_returns_response_on_success(self, dns_service):
|
||||
"""lookup should return DNSLookupResponse on success."""
|
||||
request = DNSLookupRequest(domain="example.com", record_type="A")
|
||||
|
||||
# Mock the resolver
|
||||
mock_answer = MagicMock()
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.__str__ = MagicMock(return_value="93.184.216.34")
|
||||
mock_answer.__iter__ = MagicMock(return_value=iter([mock_rdata]))
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.return_value = mock_answer
|
||||
mock_resolver.nameservers = ["8.8.8.8"]
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
assert response.success is True
|
||||
assert response.domain == "example.com"
|
||||
assert response.record_type == "A"
|
||||
assert len(response.records) > 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_uses_custom_nameserver(self, dns_service):
|
||||
"""lookup should use custom nameserver when specified."""
|
||||
request = DNSLookupRequest(
|
||||
domain="example.com",
|
||||
record_type="A",
|
||||
nameserver="1.1.1.1"
|
||||
)
|
||||
|
||||
mock_answer = MagicMock()
|
||||
mock_answer.__iter__ = MagicMock(return_value=iter([]))
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.return_value = mock_answer
|
||||
mock_resolver.nameservers = []
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
# Verify nameserver was set
|
||||
assert mock_resolver.nameservers == ["1.1.1.1"]
|
||||
assert response.nameserver_used == "1.1.1.1"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_handles_nxdomain(self, dns_service):
|
||||
"""lookup should handle NXDOMAIN (domain not found)."""
|
||||
request = DNSLookupRequest(domain="nonexistent.invalid", record_type="A")
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.side_effect = dns.resolver.NXDOMAIN()
|
||||
mock_resolver.nameservers = ["8.8.8.8"]
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
assert response.success is False
|
||||
assert "Domain not found" in response.error_message
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_handles_no_answer(self, dns_service):
|
||||
"""lookup should handle NoAnswer (no records of type)."""
|
||||
request = DNSLookupRequest(domain="example.com", record_type="AAAA")
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.side_effect = dns.resolver.NoAnswer()
|
||||
mock_resolver.nameservers = ["8.8.8.8"]
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
assert response.success is False
|
||||
assert "No AAAA records found" in response.error_message
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_handles_timeout(self, dns_service):
|
||||
"""lookup should handle DNS timeout."""
|
||||
request = DNSLookupRequest(domain="example.com", record_type="A")
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.side_effect = dns.resolver.Timeout()
|
||||
mock_resolver.nameservers = ["8.8.8.8"]
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
assert response.success is False
|
||||
assert "timeout" in response.error_message.lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_handles_dns_exception(self, dns_service):
|
||||
"""lookup should handle generic DNS exceptions."""
|
||||
request = DNSLookupRequest(domain="example.com", record_type="A")
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.side_effect = dns.exception.DNSException("DNS error")
|
||||
mock_resolver.nameservers = ["8.8.8.8"]
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
assert response.success is False
|
||||
assert "DNS error" in response.error_message
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lookup_handles_unexpected_exception(self, dns_service):
|
||||
"""lookup should handle unexpected exceptions."""
|
||||
request = DNSLookupRequest(domain="example.com", record_type="A")
|
||||
|
||||
with patch("dns.resolver.Resolver") as mock_resolver_class:
|
||||
mock_resolver = MagicMock()
|
||||
mock_resolver.resolve.side_effect = Exception("Unexpected error")
|
||||
mock_resolver.nameservers = ["8.8.8.8"]
|
||||
mock_resolver_class.return_value = mock_resolver
|
||||
|
||||
response = await dns_service.lookup(request)
|
||||
|
||||
assert response.success is False
|
||||
assert "Unexpected error" in response.error_message
|
||||
|
||||
|
||||
class TestDNSServiceParseRecord:
|
||||
"""Test record parsing."""
|
||||
|
||||
def test_parse_a_record(self, dns_service):
|
||||
"""_parse_record should parse A record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.__str__ = MagicMock(return_value="192.168.1.1")
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "A")
|
||||
|
||||
assert record is not None
|
||||
assert record.value == "192.168.1.1"
|
||||
|
||||
def test_parse_aaaa_record(self, dns_service):
|
||||
"""_parse_record should parse AAAA record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.__str__ = MagicMock(return_value="2001:db8::1")
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "AAAA")
|
||||
|
||||
assert record is not None
|
||||
assert record.value == "2001:db8::1"
|
||||
|
||||
def test_parse_mx_record(self, dns_service):
|
||||
"""_parse_record should parse MX record with priority."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.exchange = "mail.example.com"
|
||||
mock_rdata.preference = 10
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "MX")
|
||||
|
||||
assert record is not None
|
||||
assert "mail.example.com" in record.value
|
||||
assert record.priority == 10
|
||||
|
||||
def test_parse_txt_record(self, dns_service):
|
||||
"""_parse_record should parse TXT record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.strings = [b"v=spf1 include:_spf.google.com ~all"]
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "TXT")
|
||||
|
||||
assert record is not None
|
||||
assert "spf1" in record.value
|
||||
|
||||
def test_parse_cname_record(self, dns_service):
|
||||
"""_parse_record should parse CNAME record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.target = "alias.example.com"
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "CNAME")
|
||||
|
||||
assert record is not None
|
||||
assert "alias.example.com" in record.value
|
||||
|
||||
def test_parse_ns_record(self, dns_service):
|
||||
"""_parse_record should parse NS record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.target = "ns1.example.com"
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "NS")
|
||||
|
||||
assert record is not None
|
||||
assert "ns1.example.com" in record.value
|
||||
|
||||
def test_parse_soa_record(self, dns_service):
|
||||
"""_parse_record should parse SOA record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.mname = "ns1.example.com"
|
||||
mock_rdata.rname = "admin.example.com"
|
||||
mock_rdata.serial = 2024010101
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "SOA")
|
||||
|
||||
assert record is not None
|
||||
assert "ns1.example.com" in record.value
|
||||
assert "2024010101" in record.value
|
||||
|
||||
def test_parse_srv_record(self, dns_service):
|
||||
"""_parse_record should parse SRV record."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.target = "server.example.com"
|
||||
mock_rdata.port = 443
|
||||
mock_rdata.priority = 10
|
||||
mock_rdata.weight = 100
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "SRV")
|
||||
|
||||
assert record is not None
|
||||
assert "server.example.com" in record.value
|
||||
assert "port=443" in record.value
|
||||
assert record.priority == 10
|
||||
|
||||
def test_parse_record_returns_none_on_error(self, dns_service):
|
||||
"""_parse_record should return None on parsing error."""
|
||||
mock_rdata = MagicMock()
|
||||
mock_rdata.__str__ = MagicMock(side_effect=Exception("Parse error"))
|
||||
|
||||
record = dns_service._parse_record(mock_rdata, "A")
|
||||
|
||||
assert record is None
|
||||
|
||||
|
||||
class TestDNSServiceErrorResponse:
|
||||
"""Test error response generation."""
|
||||
|
||||
def test_error_response_includes_domain(self, dns_service):
|
||||
"""_error_response should include domain."""
|
||||
import time
|
||||
request = DNSLookupRequest(domain="test.example.com", record_type="A")
|
||||
|
||||
response = dns_service._error_response(request, "8.8.8.8", time.time(), "Test error")
|
||||
|
||||
assert response.domain == "test.example.com"
|
||||
|
||||
def test_error_response_includes_record_type(self, dns_service):
|
||||
"""_error_response should include record type."""
|
||||
import time
|
||||
request = DNSLookupRequest(domain="test.example.com", record_type="mx")
|
||||
|
||||
response = dns_service._error_response(request, "8.8.8.8", time.time(), "Test error")
|
||||
|
||||
assert response.record_type == "MX" # Should be uppercase
|
||||
|
||||
def test_error_response_has_empty_records(self, dns_service):
|
||||
"""_error_response should have empty records list."""
|
||||
import time
|
||||
request = DNSLookupRequest(domain="test.example.com", record_type="A")
|
||||
|
||||
response = dns_service._error_response(request, "8.8.8.8", time.time(), "Test error")
|
||||
|
||||
assert response.records == []
|
||||
|
||||
def test_error_response_has_success_false(self, dns_service):
|
||||
"""_error_response should have success=False."""
|
||||
import time
|
||||
request = DNSLookupRequest(domain="test.example.com", record_type="A")
|
||||
|
||||
response = dns_service._error_response(request, "8.8.8.8", time.time(), "Test error")
|
||||
|
||||
assert response.success is False
|
||||
|
||||
def test_error_response_includes_error_message(self, dns_service):
|
||||
"""_error_response should include error message."""
|
||||
import time
|
||||
request = DNSLookupRequest(domain="test.example.com", record_type="A")
|
||||
|
||||
response = dns_service._error_response(request, "8.8.8.8", time.time(), "Specific error")
|
||||
|
||||
assert response.error_message == "Specific error"
|
||||
@@ -122,3 +122,142 @@ class TestOpenAPIEndpoint:
|
||||
"""ReDoc should be available."""
|
||||
response = client.get("/redoc")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestFullHealthCheck:
|
||||
"""Test /health/full endpoint."""
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_full_health_returns_503_when_unhealthy(self, mock_get_ollama, client):
|
||||
"""Full health should return 503 when Ollama unhealthy."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = False
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/full")
|
||||
assert response.status_code == 503
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_full_health_returns_components_status(self, mock_get_ollama, client):
|
||||
"""Full health should return component status."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = False
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/full")
|
||||
data = response.json()
|
||||
|
||||
assert "status" in data
|
||||
assert "components" in data
|
||||
assert "ollama" in data["components"]
|
||||
assert "response_time_ms" in data
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_full_health_handles_list_models_error(self, mock_get_ollama, client):
|
||||
"""Full health should handle list_models errors."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_client.list_models.side_effect = Exception("Connection error")
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/full")
|
||||
data = response.json()
|
||||
|
||||
# Should report error in component status
|
||||
assert "ollama" in data["components"]
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_full_health_handles_health_check_exception(self, mock_get_ollama, client):
|
||||
"""Full health should handle health check exceptions gracefully."""
|
||||
mock_client = AsyncMock()
|
||||
# Return False instead of raising exception to test unhealthy path
|
||||
mock_client.health_check.return_value = False
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/full")
|
||||
# Should return 503 for unhealthy
|
||||
assert response.status_code == 503
|
||||
data = response.json()
|
||||
assert data["status"] == "unhealthy"
|
||||
|
||||
|
||||
class TestDiagnosticsEndpoint:
|
||||
"""Test /health/diagnostics endpoint."""
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_diagnostics_returns_200(self, mock_get_ollama, client):
|
||||
"""Diagnostics should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/diagnostics")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_diagnostics_returns_service_info(self, mock_get_ollama, client):
|
||||
"""Diagnostics should return service information."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/diagnostics")
|
||||
data = response.json()
|
||||
|
||||
assert "service" in data
|
||||
assert "name" in data["service"]
|
||||
assert "version" in data["service"]
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_diagnostics_returns_components(self, mock_get_ollama, client):
|
||||
"""Diagnostics should return component details."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/diagnostics")
|
||||
data = response.json()
|
||||
|
||||
assert "components" in data
|
||||
assert "ollama" in data["components"]
|
||||
assert "agent" in data["components"]
|
||||
assert "qdrant" in data["components"]
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_diagnostics_returns_configuration(self, mock_get_ollama, client):
|
||||
"""Diagnostics should return configuration info."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/diagnostics")
|
||||
data = response.json()
|
||||
|
||||
assert "configuration" in data
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_diagnostics_returns_response_time(self, mock_get_ollama, client):
|
||||
"""Diagnostics should return response time."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = True
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/diagnostics")
|
||||
data = response.json()
|
||||
|
||||
assert "response_time_ms" in data
|
||||
assert isinstance(data["response_time_ms"], int)
|
||||
|
||||
@patch("src.controllers.health_controller.get_ollama_client")
|
||||
def test_diagnostics_handles_ollama_error(self, mock_get_ollama, client):
|
||||
"""Diagnostics should handle Ollama connection errors."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.side_effect = Exception("Connection refused")
|
||||
mock_get_ollama.return_value = mock_client
|
||||
|
||||
response = client.get("/health/diagnostics")
|
||||
data = response.json()
|
||||
|
||||
# Should still return 200 with error info
|
||||
assert response.status_code == 200
|
||||
assert "error" in data["components"]["ollama"]
|
||||
|
||||
@@ -0,0 +1,471 @@
|
||||
"""Tests for Home Assistant client."""
|
||||
import pytest
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
import httpx
|
||||
|
||||
from src.clients.homeassistant_client import HomeAssistantClient, get_homeassistant_client
|
||||
|
||||
|
||||
class TestHomeAssistantClientInit:
|
||||
"""Test HomeAssistantClient initialization."""
|
||||
|
||||
@patch("src.clients.homeassistant_client.settings")
|
||||
def test_uses_settings_defaults(self, mock_settings):
|
||||
"""Client should use settings for defaults."""
|
||||
mock_settings.homeassistant_url = "http://ha.local:8123"
|
||||
mock_settings.homeassistant_token = "test_token"
|
||||
|
||||
client = HomeAssistantClient()
|
||||
|
||||
assert client.base_url == "http://ha.local:8123"
|
||||
assert client.token == "test_token"
|
||||
|
||||
def test_accepts_custom_url_and_token(self):
|
||||
"""Client should accept custom URL and token."""
|
||||
client = HomeAssistantClient(
|
||||
base_url="http://custom:8123",
|
||||
token="custom_token"
|
||||
)
|
||||
|
||||
assert client.base_url == "http://custom:8123"
|
||||
assert client.token == "custom_token"
|
||||
|
||||
def test_strips_trailing_slash_from_url(self):
|
||||
"""Client should strip trailing slash from URL."""
|
||||
client = HomeAssistantClient(
|
||||
base_url="http://custom:8123/",
|
||||
token="token"
|
||||
)
|
||||
|
||||
assert client.base_url == "http://custom:8123"
|
||||
|
||||
@patch("src.clients.homeassistant_client.logger")
|
||||
@patch("src.clients.homeassistant_client.settings")
|
||||
def test_warns_when_token_missing(self, mock_settings, mock_logger):
|
||||
"""Client should warn when token is not configured."""
|
||||
mock_settings.homeassistant_url = "http://ha.local:8123"
|
||||
mock_settings.homeassistant_token = ""
|
||||
|
||||
HomeAssistantClient()
|
||||
|
||||
mock_logger.warning.assert_called_once()
|
||||
|
||||
|
||||
class TestHomeAssistantClientHeaders:
|
||||
"""Test header generation."""
|
||||
|
||||
def test_get_headers_includes_bearer_token(self):
|
||||
"""Headers should include Bearer token."""
|
||||
client = HomeAssistantClient(
|
||||
base_url="http://ha:8123",
|
||||
token="my_token"
|
||||
)
|
||||
|
||||
headers = client._get_headers()
|
||||
|
||||
assert headers["Authorization"] == "Bearer my_token"
|
||||
assert headers["Content-Type"] == "application/json"
|
||||
|
||||
|
||||
class TestHomeAssistantClientHealthCheck:
|
||||
"""Test health check functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_healthy(self):
|
||||
"""Health check should return healthy when HA responds."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"version": "2024.12.0"}
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result["status"] == "healthy"
|
||||
assert result["connected"] is True
|
||||
assert result["platform"] == "home_assistant"
|
||||
assert result["version"] == "2024.12.0"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_unhealthy_on_error(self):
|
||||
"""Health check should return unhealthy on connection error."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.side_effect = Exception("Connection refused")
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result["status"] == "unhealthy"
|
||||
assert result["connected"] is False
|
||||
assert "error" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_unhealthy_on_non_200(self):
|
||||
"""Health check should return unhealthy on non-200 status."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 401
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result["status"] == "unhealthy"
|
||||
assert result["connected"] is False
|
||||
|
||||
|
||||
class TestHomeAssistantClientStates:
|
||||
"""Test state retrieval methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_states_returns_list(self):
|
||||
"""get_states should return list of states."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
states = [
|
||||
{"entity_id": "light.test", "state": "on"},
|
||||
{"entity_id": "switch.test", "state": "off"}
|
||||
]
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = states
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_states()
|
||||
|
||||
assert result == states
|
||||
assert len(result) == 2
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_state_returns_single_entity(self):
|
||||
"""get_state should return single entity state."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
state = {"entity_id": "light.test", "state": "on", "attributes": {}}
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = state
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_state("light.test")
|
||||
|
||||
assert result == state
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_state_returns_none_for_404(self):
|
||||
"""get_state should return None for non-existent entity."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 404
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_state("light.nonexistent")
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
class TestHomeAssistantClientServices:
|
||||
"""Test service call methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_call_service_posts_to_correct_endpoint(self):
|
||||
"""call_service should POST to /api/services/{domain}/{service}."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.call_service("light", "turn_on", "light.test")
|
||||
|
||||
# Verify the correct URL was called
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/light/turn_on" in call_args[0][0]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_turn_on_calls_correct_service(self):
|
||||
"""turn_on should call the turn_on service with attributes."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.turn_on("light.test", brightness=128)
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/light/turn_on" in call_args[0][0]
|
||||
# Check that brightness was passed in the payload
|
||||
payload = call_args[1]["json"]
|
||||
assert payload["entity_id"] == "light.test"
|
||||
assert payload["brightness"] == 128
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_turn_off_calls_correct_service(self):
|
||||
"""turn_off should call the turn_off service."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.turn_off("switch.test")
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/switch/turn_off" in call_args[0][0]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_toggle_calls_correct_service(self):
|
||||
"""toggle should call the toggle service."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.toggle("light.test")
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/light/toggle" in call_args[0][0]
|
||||
|
||||
|
||||
class TestHomeAssistantClientScenes:
|
||||
"""Test scene methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_activate_scene_calls_scene_turn_on(self):
|
||||
"""activate_scene should call scene.turn_on service."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.activate_scene("scene.movie_night")
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/scene/turn_on" in call_args[0][0]
|
||||
|
||||
|
||||
class TestHomeAssistantClientScripts:
|
||||
"""Test script methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_run_script_calls_script_turn_on(self):
|
||||
"""run_script should call script.turn_on service."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.run_script("script.bedtime", {"delay": 5})
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/script/turn_on" in call_args[0][0]
|
||||
|
||||
|
||||
class TestHomeAssistantClientAutomations:
|
||||
"""Test automation methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_enable_automation_calls_turn_on(self):
|
||||
"""enable_automation should call automation.turn_on."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.enable_automation("automation.motion")
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/automation/turn_on" in call_args[0][0]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disable_automation_calls_turn_off(self):
|
||||
"""disable_automation should call automation.turn_off."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.disable_automation("automation.motion")
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/services/automation/turn_off" in call_args[0][0]
|
||||
|
||||
|
||||
class TestHomeAssistantClientHistory:
|
||||
"""Test history methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_history_calls_correct_endpoint(self):
|
||||
"""get_history should call /api/history/period endpoint."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = [[]]
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.get_history("light.test", hours=24)
|
||||
|
||||
call_args = mock_client.get.call_args
|
||||
assert "/api/history/period/" in call_args[0][0]
|
||||
assert call_args[1]["params"]["filter_entity_id"] == "light.test"
|
||||
|
||||
|
||||
class TestHomeAssistantClientAreas:
|
||||
"""Test areas method."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_areas_uses_template_api(self):
|
||||
"""get_areas should use the template API."""
|
||||
client = HomeAssistantClient(base_url="http://ha:8123", token="token")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.text = '[{"id": "living_room", "name": "Living Room"}]'
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_areas()
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert "/api/template" in call_args[0][0]
|
||||
assert result == [{"id": "living_room", "name": "Living Room"}]
|
||||
|
||||
|
||||
class TestGetHomeAssistantClientSingleton:
|
||||
"""Test singleton pattern."""
|
||||
|
||||
def test_returns_same_instance(self):
|
||||
"""get_homeassistant_client should return singleton."""
|
||||
# Reset singleton
|
||||
import src.clients.homeassistant_client as module
|
||||
module._homeassistant_client = None
|
||||
|
||||
client1 = get_homeassistant_client()
|
||||
client2 = get_homeassistant_client()
|
||||
|
||||
assert client1 is client2
|
||||
@@ -0,0 +1,655 @@
|
||||
"""Tests for housekeeping (home automation) endpoints."""
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from unittest.mock import patch, AsyncMock
|
||||
|
||||
from src.main import app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client():
|
||||
"""Create a test client."""
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_ha_client():
|
||||
"""Create a mock Home Assistant client."""
|
||||
mock = AsyncMock()
|
||||
return mock
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_states():
|
||||
"""Sample Home Assistant states for testing."""
|
||||
return [
|
||||
{
|
||||
"entity_id": "light.living_room",
|
||||
"state": "on",
|
||||
"attributes": {
|
||||
"friendly_name": "Living Room Light",
|
||||
"brightness": 255,
|
||||
"area_id": "living_room"
|
||||
},
|
||||
"last_changed": "2025-01-01T12:00:00Z"
|
||||
},
|
||||
{
|
||||
"entity_id": "light.bedroom",
|
||||
"state": "off",
|
||||
"attributes": {
|
||||
"friendly_name": "Bedroom Light",
|
||||
"area_id": "bedroom"
|
||||
},
|
||||
"last_changed": "2025-01-01T11:00:00Z"
|
||||
},
|
||||
{
|
||||
"entity_id": "switch.garage",
|
||||
"state": "off",
|
||||
"attributes": {
|
||||
"friendly_name": "Garage Switch"
|
||||
},
|
||||
"last_changed": "2025-01-01T10:00:00Z"
|
||||
},
|
||||
{
|
||||
"entity_id": "scene.movie_night",
|
||||
"state": "scening",
|
||||
"attributes": {
|
||||
"friendly_name": "Movie Night"
|
||||
},
|
||||
"last_changed": "2025-01-01T09:00:00Z"
|
||||
},
|
||||
{
|
||||
"entity_id": "script.bedtime",
|
||||
"state": "off",
|
||||
"attributes": {
|
||||
"friendly_name": "Bedtime Routine"
|
||||
},
|
||||
"last_changed": "2025-01-01T08:00:00Z"
|
||||
},
|
||||
{
|
||||
"entity_id": "automation.motion_lights",
|
||||
"state": "on",
|
||||
"attributes": {
|
||||
"friendly_name": "Motion Lights"
|
||||
},
|
||||
"last_changed": "2025-01-01T07:00:00Z"
|
||||
},
|
||||
{
|
||||
"entity_id": "sensor.temperature",
|
||||
"state": "22.5",
|
||||
"attributes": {
|
||||
"friendly_name": "Temperature",
|
||||
"unit_of_measurement": "°C"
|
||||
},
|
||||
"last_changed": "2025-01-01T06:00:00Z"
|
||||
}
|
||||
]
|
||||
|
||||
|
||||
class TestHousekeepingHealth:
|
||||
"""Test /housekeeping/health endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_health_returns_200(self, mock_get_ha, client):
|
||||
"""Health endpoint should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = {
|
||||
"status": "healthy",
|
||||
"connected": True,
|
||||
"platform": "home_assistant",
|
||||
"version": "2024.12.0"
|
||||
}
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/health")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_health_returns_connection_status(self, mock_get_ha, client):
|
||||
"""Health endpoint should return connection status."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = {
|
||||
"status": "healthy",
|
||||
"connected": True,
|
||||
"platform": "home_assistant",
|
||||
"version": "2024.12.0"
|
||||
}
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/health")
|
||||
data = response.json()
|
||||
|
||||
assert "status" in data
|
||||
assert "connected" in data
|
||||
assert "platform" in data
|
||||
assert data["platform"] == "home_assistant"
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_health_returns_unhealthy_when_disconnected(self, mock_get_ha, client):
|
||||
"""Health should report unhealthy when HA is disconnected."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.health_check.return_value = {
|
||||
"status": "unhealthy",
|
||||
"connected": False,
|
||||
"platform": "home_assistant",
|
||||
"error": "Connection refused"
|
||||
}
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/health")
|
||||
data = response.json()
|
||||
|
||||
assert data["connected"] is False
|
||||
assert data["status"] == "unhealthy"
|
||||
|
||||
|
||||
class TestHousekeepingDevices:
|
||||
"""Test /housekeeping/devices endpoints."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_devices_returns_200(self, mock_get_ha, client, sample_states):
|
||||
"""List devices should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/devices")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_devices_returns_controllable_only(self, mock_get_ha, client, sample_states):
|
||||
"""List devices should filter out non-controllable entities."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/devices")
|
||||
data = response.json()
|
||||
|
||||
# Should include lights, switches, scenes, scripts, automations
|
||||
# Should NOT include sensors
|
||||
entity_ids = [d["entity_id"] for d in data["devices"]]
|
||||
assert "light.living_room" in entity_ids
|
||||
assert "switch.garage" in entity_ids
|
||||
assert "sensor.temperature" not in entity_ids
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_devices_filter_by_domain(self, mock_get_ha, client, sample_states):
|
||||
"""List devices should filter by domain parameter."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/devices?domain=light")
|
||||
data = response.json()
|
||||
|
||||
# Should only return lights
|
||||
assert len(data["devices"]) == 2
|
||||
for device in data["devices"]:
|
||||
assert device["domain"] == "light"
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_devices_includes_attributes(self, mock_get_ha, client, sample_states):
|
||||
"""List devices should include device attributes."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/devices")
|
||||
data = response.json()
|
||||
|
||||
# Find the living room light
|
||||
living_room = next(d for d in data["devices"] if d["entity_id"] == "light.living_room")
|
||||
assert living_room["name"] == "Living Room Light"
|
||||
assert living_room["state"] == "on"
|
||||
assert "brightness" in living_room["attributes"]
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_get_device_returns_200(self, mock_get_ha, client):
|
||||
"""Get device should return 200 for existing device."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = {
|
||||
"entity_id": "light.living_room",
|
||||
"state": "on",
|
||||
"attributes": {
|
||||
"friendly_name": "Living Room Light",
|
||||
"brightness": 255
|
||||
},
|
||||
"last_changed": "2025-01-01T12:00:00Z"
|
||||
}
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/devices/light.living_room")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_get_device_returns_404_for_missing(self, mock_get_ha, client):
|
||||
"""Get device should return 404 for non-existent device."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = None
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/devices/light.nonexistent")
|
||||
assert response.status_code == 404
|
||||
|
||||
data = response.json()
|
||||
assert data["detail"]["code"] == "DEVICE_NOT_FOUND"
|
||||
|
||||
|
||||
class TestHousekeepingAreas:
|
||||
"""Test /housekeeping/areas endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_areas_returns_200(self, mock_get_ha, client):
|
||||
"""List areas should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_areas.return_value = [
|
||||
{"id": "living_room", "name": "Living Room"},
|
||||
{"id": "bedroom", "name": "Bedroom"}
|
||||
]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/areas")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_areas_returns_area_data(self, mock_get_ha, client):
|
||||
"""List areas should return area id and name."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_areas.return_value = [
|
||||
{"id": "living_room", "name": "Living Room"},
|
||||
{"id": "bedroom", "name": "Bedroom"}
|
||||
]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/areas")
|
||||
data = response.json()
|
||||
|
||||
assert "areas" in data
|
||||
assert len(data["areas"]) == 2
|
||||
assert data["areas"][0]["id"] == "living_room"
|
||||
assert data["areas"][0]["name"] == "Living Room"
|
||||
|
||||
|
||||
class TestHousekeepingScenes:
|
||||
"""Test /housekeeping/scenes endpoints."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_scenes_returns_200(self, mock_get_ha, client, sample_states):
|
||||
"""List scenes should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/scenes")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_scenes_returns_only_scenes(self, mock_get_ha, client, sample_states):
|
||||
"""List scenes should only return scene entities."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/scenes")
|
||||
data = response.json()
|
||||
|
||||
assert "scenes" in data
|
||||
assert len(data["scenes"]) == 1
|
||||
assert data["scenes"][0]["id"] == "scene.movie_night"
|
||||
assert data["scenes"][0]["name"] == "Movie Night"
|
||||
|
||||
|
||||
class TestHousekeepingScripts:
|
||||
"""Test /housekeeping/scripts endpoints."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_scripts_returns_200(self, mock_get_ha, client, sample_states):
|
||||
"""List scripts should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/scripts")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_scripts_returns_only_scripts(self, mock_get_ha, client, sample_states):
|
||||
"""List scripts should only return script entities."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/scripts")
|
||||
data = response.json()
|
||||
|
||||
assert "scripts" in data
|
||||
assert len(data["scripts"]) == 1
|
||||
assert data["scripts"][0]["id"] == "script.bedtime"
|
||||
|
||||
|
||||
class TestHousekeepingAutomations:
|
||||
"""Test /housekeeping/automations endpoints."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_automations_returns_200(self, mock_get_ha, client, sample_states):
|
||||
"""List automations should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/automations")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_list_automations_includes_enabled_status(self, mock_get_ha, client, sample_states):
|
||||
"""List automations should include enabled status."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_states.return_value = sample_states
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/automations")
|
||||
data = response.json()
|
||||
|
||||
assert "automations" in data
|
||||
assert len(data["automations"]) == 1
|
||||
assert data["automations"][0]["id"] == "automation.motion_lights"
|
||||
assert data["automations"][0]["enabled"] is True
|
||||
|
||||
|
||||
class TestHousekeepingHistory:
|
||||
"""Test /housekeeping/history endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_history_returns_200(self, mock_get_ha, client):
|
||||
"""History endpoint should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_history.return_value = [[
|
||||
{"state": "on", "last_changed": "2025-01-01T12:00:00Z", "attributes": {}},
|
||||
{"state": "off", "last_changed": "2025-01-01T11:00:00Z", "attributes": {}}
|
||||
]]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/history?entity_id=light.living_room")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_history_returns_entries(self, mock_get_ha, client):
|
||||
"""History endpoint should return history entries."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_history.return_value = [[
|
||||
{"state": "on", "last_changed": "2025-01-01T12:00:00Z", "attributes": {"brightness": 255}},
|
||||
{"state": "off", "last_changed": "2025-01-01T11:00:00Z", "attributes": {}}
|
||||
]]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.get("/housekeeping/history?entity_id=light.living_room&hours=24")
|
||||
data = response.json()
|
||||
|
||||
assert "entity_id" in data
|
||||
assert "history" in data
|
||||
assert data["entity_id"] == "light.living_room"
|
||||
assert len(data["history"]) == 2
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_history_requires_entity_id(self, mock_get_ha, client):
|
||||
"""History endpoint should require entity_id parameter."""
|
||||
response = client.get("/housekeeping/history")
|
||||
assert response.status_code == 422 # Validation error
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_history_validates_hours_range(self, mock_get_ha, client):
|
||||
"""History endpoint should validate hours range (1-168)."""
|
||||
mock_client = AsyncMock()
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
# Too high
|
||||
response = client.get("/housekeeping/history?entity_id=light.test&hours=200")
|
||||
assert response.status_code == 422
|
||||
|
||||
# Too low
|
||||
response = client.get("/housekeeping/history?entity_id=light.test&hours=0")
|
||||
assert response.status_code == 422
|
||||
|
||||
|
||||
class TestHousekeepingDeviceControl:
|
||||
"""Test /housekeeping/devices/{entity_id}/control endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_control_device_turn_on(self, mock_get_ha, client):
|
||||
"""Control should turn on device."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = {
|
||||
"entity_id": "light.living_room",
|
||||
"state": "on",
|
||||
"attributes": {"brightness": 255}
|
||||
}
|
||||
mock_client.turn_on.return_value = [{"entity_id": "light.living_room"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/devices/light.living_room/control",
|
||||
json={"action": "turn_on"}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_control_device_turn_off(self, mock_get_ha, client):
|
||||
"""Control should turn off device."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = {
|
||||
"entity_id": "light.living_room",
|
||||
"state": "off",
|
||||
"attributes": {}
|
||||
}
|
||||
mock_client.turn_off.return_value = [{"entity_id": "light.living_room"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/devices/light.living_room/control",
|
||||
json={"action": "turn_off"}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_control_device_toggle(self, mock_get_ha, client):
|
||||
"""Control should toggle device."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = {
|
||||
"entity_id": "light.living_room",
|
||||
"state": "on",
|
||||
"attributes": {}
|
||||
}
|
||||
mock_client.toggle.return_value = [{"entity_id": "light.living_room"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/devices/light.living_room/control",
|
||||
json={"action": "toggle"}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_control_device_with_brightness(self, mock_get_ha, client):
|
||||
"""Control should set brightness."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = {
|
||||
"entity_id": "light.living_room",
|
||||
"state": "on",
|
||||
"attributes": {"brightness": 128}
|
||||
}
|
||||
mock_client.turn_on.return_value = [{"entity_id": "light.living_room"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/devices/light.living_room/control",
|
||||
json={"action": "turn_on", "brightness": 128}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
mock_client.turn_on.assert_called_once()
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_control_device_returns_404_for_missing(self, mock_get_ha, client):
|
||||
"""Control should return 404 for non-existent device."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = None
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/devices/light.nonexistent/control",
|
||||
json={"action": "turn_on"}
|
||||
)
|
||||
assert response.status_code == 404
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_control_device_returns_error_response(self, mock_get_ha, client):
|
||||
"""Control should return proper error response."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get_state.return_value = {
|
||||
"entity_id": "light.living_room",
|
||||
"state": "on",
|
||||
"attributes": {}
|
||||
}
|
||||
mock_client.turn_on.side_effect = Exception("Service unavailable")
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/devices/light.living_room/control",
|
||||
json={"action": "turn_on"}
|
||||
)
|
||||
assert response.status_code == 500
|
||||
|
||||
|
||||
class TestHousekeepingSceneActivation:
|
||||
"""Test /housekeeping/scenes/{scene_id}/activate endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_activate_scene_returns_200(self, mock_get_ha, client):
|
||||
"""Activate scene should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.activate_scene.return_value = [{"entity_id": "scene.movie_night"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post("/housekeeping/scenes/scene.movie_night/activate")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_activate_scene_returns_success_response(self, mock_get_ha, client):
|
||||
"""Activate scene should return success response."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.activate_scene.return_value = [{"entity_id": "scene.movie_night"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post("/housekeeping/scenes/scene.movie_night/activate")
|
||||
data = response.json()
|
||||
|
||||
assert data["success"] is True
|
||||
assert data["scene_id"] == "scene.movie_night"
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_activate_scene_handles_error(self, mock_get_ha, client):
|
||||
"""Activate scene should handle errors."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.activate_scene.side_effect = Exception("Service error")
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post("/housekeeping/scenes/scene.movie_night/activate")
|
||||
assert response.status_code == 500
|
||||
|
||||
|
||||
class TestHousekeepingScriptRun:
|
||||
"""Test /housekeeping/scripts/{script_id}/run endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_run_script_returns_200(self, mock_get_ha, client):
|
||||
"""Run script should return 200."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.run_script.return_value = [{"entity_id": "script.bedtime"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post("/housekeeping/scripts/script.bedtime/run")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_run_script_returns_success_response(self, mock_get_ha, client):
|
||||
"""Run script should return success response."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.run_script.return_value = [{"entity_id": "script.bedtime"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post("/housekeeping/scripts/script.bedtime/run")
|
||||
data = response.json()
|
||||
|
||||
assert data["success"] is True
|
||||
assert data["script_id"] == "script.bedtime"
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_run_script_handles_error(self, mock_get_ha, client):
|
||||
"""Run script should handle errors."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.run_script.side_effect = Exception("Script error")
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post("/housekeeping/scripts/script.bedtime/run")
|
||||
assert response.status_code == 500
|
||||
|
||||
|
||||
class TestHousekeepingAutomationToggle:
|
||||
"""Test /housekeeping/automations/{automation_id}/toggle endpoint."""
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_toggle_automation_enable(self, mock_get_ha, client):
|
||||
"""Toggle automation should enable when requested."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.enable_automation.return_value = [{"entity_id": "automation.motion_lights"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/automations/automation.motion_lights/toggle",
|
||||
json={"enabled": True}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_toggle_automation_disable(self, mock_get_ha, client):
|
||||
"""Toggle automation should disable when requested."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.disable_automation.return_value = [{"entity_id": "automation.motion_lights"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/automations/automation.motion_lights/toggle",
|
||||
json={"enabled": False}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
mock_client.disable_automation.assert_called_once()
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_toggle_automation_returns_new_state(self, mock_get_ha, client):
|
||||
"""Toggle automation should return new enabled state."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.enable_automation.return_value = [{"entity_id": "automation.motion_lights"}]
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/automations/automation.motion_lights/toggle",
|
||||
json={"enabled": True}
|
||||
)
|
||||
data = response.json()
|
||||
|
||||
assert data["success"] is True
|
||||
assert data["automation_id"] == "automation.motion_lights"
|
||||
assert data["enabled"] is True
|
||||
|
||||
@patch("src.controllers.housekeeping_controller.get_homeassistant_client")
|
||||
def test_toggle_automation_handles_error(self, mock_get_ha, client):
|
||||
"""Toggle automation should handle errors."""
|
||||
mock_client = AsyncMock()
|
||||
mock_client.enable_automation.side_effect = Exception("Automation error")
|
||||
mock_get_ha.return_value = mock_client
|
||||
|
||||
response = client.post(
|
||||
"/housekeeping/automations/automation.motion_lights/toggle",
|
||||
json={"enabled": True}
|
||||
)
|
||||
assert response.status_code == 500
|
||||
@@ -0,0 +1,404 @@
|
||||
"""Tests for infrastructure endpoints."""
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
|
||||
from src.main import app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client():
|
||||
"""Create a test client."""
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_portainer():
|
||||
"""Create a mock Portainer client."""
|
||||
mock = AsyncMock()
|
||||
return mock
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_npm():
|
||||
"""Create a mock NPM client."""
|
||||
mock = AsyncMock()
|
||||
return mock
|
||||
|
||||
|
||||
class TestInfrastructureHealth:
|
||||
"""Test /infrastructure/health endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_health_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Health endpoint should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.health_check.return_value = True
|
||||
mock_portainer.get_stacks.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.health_check.return_value = True
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/health")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_health_returns_connection_status(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Health endpoint should return connection status for both services."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.health_check.return_value = True
|
||||
mock_portainer.get_stacks.return_value = [{"Id": 1}, {"Id": 2}]
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.health_check.return_value = True
|
||||
mock_npm.get_proxy_hosts.return_value = [{"id": 1}]
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/health")
|
||||
data = response.json()
|
||||
|
||||
assert "portainer_connected" in data
|
||||
assert "npm_connected" in data
|
||||
assert "total_stacks" in data
|
||||
assert "total_proxy_hosts" in data
|
||||
assert data["portainer_connected"] is True
|
||||
assert data["npm_connected"] is True
|
||||
assert data["total_stacks"] == 2
|
||||
assert data["total_proxy_hosts"] == 1
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_health_handles_disconnected_services(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Health should handle when services are disconnected."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.health_check.return_value = False
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.health_check.return_value = False
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/health")
|
||||
data = response.json()
|
||||
|
||||
assert data["portainer_connected"] is False
|
||||
assert data["npm_connected"] is False
|
||||
assert data["total_stacks"] == 0
|
||||
assert data["total_proxy_hosts"] == 0
|
||||
|
||||
|
||||
class TestInfrastructureServices:
|
||||
"""Test /infrastructure/services endpoints."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_list_services_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""List services should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.get_stacks.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/services")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_list_services_returns_stack_info(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""List services should return stack information."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.get_stacks.return_value = [
|
||||
{"Id": 1, "Name": "stack1", "Status": 1, "EndpointId": 1},
|
||||
{"Id": 2, "Name": "stack2", "Status": 2, "EndpointId": 1}
|
||||
]
|
||||
mock_portainer.get_containers.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/services")
|
||||
data = response.json()
|
||||
|
||||
assert isinstance(data, list)
|
||||
assert len(data) == 2
|
||||
assert data[0]["name"] == "stack1"
|
||||
assert data[1]["name"] == "stack2"
|
||||
|
||||
|
||||
class TestInfrastructurePorts:
|
||||
"""Test /infrastructure/ports endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_list_ports_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""List ports should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.get_endpoints.return_value = [{"Id": 1}]
|
||||
mock_portainer.get_containers.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/ports")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestInfrastructureDomains:
|
||||
"""Test /infrastructure/domains endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_list_domains_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""List domains should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/domains")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_list_domains_returns_domain_info(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""List domains should return domain information."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = [
|
||||
{
|
||||
"id": 1,
|
||||
"domain_names": ["example.com", "www.example.com"],
|
||||
"forward_host": "app",
|
||||
"forward_port": 8080,
|
||||
"ssl_certificate_id": 1
|
||||
}
|
||||
]
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/domains")
|
||||
data = response.json()
|
||||
|
||||
assert isinstance(data, list)
|
||||
# Each domain name should be a separate entry
|
||||
assert len(data) >= 1
|
||||
|
||||
|
||||
class TestInfrastructureContainers:
|
||||
"""Test /infrastructure/containers endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_list_containers_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""List containers should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.list_containers.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/containers")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestInfrastructureWidgetData:
|
||||
"""Test /infrastructure/widget-data endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_widget_data_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Widget data should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.health_check.return_value = True
|
||||
mock_portainer.get_stacks.return_value = []
|
||||
mock_portainer.list_containers.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.health_check.return_value = True
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/widget-data")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestInfrastructureServiceGroups:
|
||||
"""Test /infrastructure/service-groups endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_service_groups_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Service groups should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/service-groups")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_service_groups_returns_group_data(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Service groups should return group data."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/service-groups")
|
||||
data = response.json()
|
||||
|
||||
# Should return a dict or list of service groups
|
||||
assert isinstance(data, (dict, list))
|
||||
|
||||
|
||||
class TestInfrastructureResources:
|
||||
"""Test /infrastructure/resources endpoints."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_system_resources_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""System resources should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/resources/system")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_container_resources_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Container resources should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.list_containers.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/resources/containers")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestInfrastructureServiceStatus:
|
||||
"""Test /infrastructure/services/{service}/status endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_service_status_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Service status should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.get_stacks.return_value = [
|
||||
{"Id": 1, "Name": "testservice", "Status": 1, "EndpointId": 1}
|
||||
]
|
||||
mock_portainer.get_containers.return_value = [
|
||||
{"Names": ["/testservice_app_1"], "State": "running"}
|
||||
]
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/services/testservice/status")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestInfrastructureContainerActions:
|
||||
"""Test container action endpoints."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_get_container_logs_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Get container logs should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.list_containers.return_value = [
|
||||
{"Names": ["/testcontainer"], "Id": "abc123"}
|
||||
]
|
||||
mock_portainer.get_endpoints.return_value = [{"Id": 1}]
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/containers/testcontainer/logs")
|
||||
# Response depends on container existence
|
||||
assert response.status_code in [200, 404]
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_get_single_container_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Get single container should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.inspect_container.return_value = {
|
||||
"Id": "abc123",
|
||||
"Name": "/testcontainer",
|
||||
"State": {"Status": "running"}
|
||||
}
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/containers/testcontainer")
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestInfrastructureGetService:
|
||||
"""Test /infrastructure/services/{name} endpoint."""
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_get_service_returns_200(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Get service should return 200."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.get_stacks.return_value = [
|
||||
{"Id": 1, "Name": "testservice", "Status": 1, "EndpointId": 1}
|
||||
]
|
||||
mock_portainer.get_containers.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_npm.get_proxy_hosts.return_value = []
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/services/testservice")
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.infrastructure_controller.get_portainer_client")
|
||||
@patch("src.controllers.infrastructure_controller.get_npm_client")
|
||||
def test_get_service_returns_404_for_missing(self, mock_get_npm, mock_get_portainer, client):
|
||||
"""Get service should return 404 for non-existent service."""
|
||||
mock_portainer = AsyncMock()
|
||||
mock_portainer.get_stacks.return_value = []
|
||||
mock_get_portainer.return_value = mock_portainer
|
||||
|
||||
mock_npm = AsyncMock()
|
||||
mock_get_npm.return_value = mock_npm
|
||||
|
||||
response = client.get("/infrastructure/services/nonexistent")
|
||||
assert response.status_code == 404
|
||||
@@ -0,0 +1,398 @@
|
||||
"""Tests for NPM client."""
|
||||
import pytest
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
from src.clients.npm_client import NPMClient, get_npm_client
|
||||
|
||||
|
||||
class TestNPMClientInit:
|
||||
"""Test NPMClient initialization."""
|
||||
|
||||
@patch("src.clients.npm_client.settings")
|
||||
def test_uses_settings_defaults(self, mock_settings):
|
||||
"""Client should use settings for defaults."""
|
||||
mock_settings.npm_url = "http://npm:81"
|
||||
mock_settings.npm_email = "admin@example.com"
|
||||
mock_settings.npm_password = "password123"
|
||||
|
||||
client = NPMClient()
|
||||
|
||||
assert client.base_url == "http://npm:81"
|
||||
assert client.email == "admin@example.com"
|
||||
assert client.password == "password123"
|
||||
|
||||
def test_accepts_custom_credentials(self):
|
||||
"""Client should accept custom credentials."""
|
||||
client = NPMClient(
|
||||
base_url="http://custom:81",
|
||||
email="custom@example.com",
|
||||
password="custom_pass"
|
||||
)
|
||||
|
||||
assert client.base_url == "http://custom:81"
|
||||
assert client.email == "custom@example.com"
|
||||
assert client.password == "custom_pass"
|
||||
|
||||
def test_strips_trailing_slash_from_url(self):
|
||||
"""Client should strip trailing slash from URL."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81/",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
|
||||
assert client.base_url == "http://npm:81"
|
||||
|
||||
@patch("src.clients.npm_client.logger")
|
||||
@patch("src.clients.npm_client.settings")
|
||||
def test_warns_when_credentials_missing(self, mock_settings, mock_logger):
|
||||
"""Client should warn when credentials are not configured."""
|
||||
mock_settings.npm_url = "http://npm:81"
|
||||
mock_settings.npm_email = ""
|
||||
mock_settings.npm_password = ""
|
||||
|
||||
NPMClient()
|
||||
|
||||
mock_logger.warning.assert_called_once()
|
||||
|
||||
def test_initializes_token_as_none(self):
|
||||
"""Client should initialize token as None."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
|
||||
assert client._token is None
|
||||
assert client._token_expires is None
|
||||
|
||||
|
||||
class TestNPMClientHeaders:
|
||||
"""Test header generation."""
|
||||
|
||||
def test_get_headers_raises_without_token(self):
|
||||
"""Headers should raise if no token available."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
|
||||
with pytest.raises(RuntimeError, match="No NPM token available"):
|
||||
client._get_headers()
|
||||
|
||||
def test_get_headers_includes_bearer_token(self):
|
||||
"""Headers should include Bearer token when available."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
client._token = "test_token_123"
|
||||
|
||||
headers = client._get_headers()
|
||||
|
||||
assert headers["Authorization"] == "Bearer test_token_123"
|
||||
assert headers["Content-Type"] == "application/json"
|
||||
|
||||
|
||||
class TestNPMClientToken:
|
||||
"""Test token management."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_refresh_token_stores_token(self):
|
||||
"""_refresh_token should store token from response."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"token": "new_token_abc"}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client._refresh_token()
|
||||
|
||||
assert client._token == "new_token_abc"
|
||||
assert client._token_expires is not None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ensure_token_refreshes_when_none(self):
|
||||
"""_ensure_token should refresh when no token."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
|
||||
with patch.object(client, "_refresh_token", new_callable=AsyncMock) as mock_refresh:
|
||||
await client._ensure_token()
|
||||
mock_refresh.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_ensure_token_skips_refresh_when_valid(self):
|
||||
"""_ensure_token should skip refresh when token is valid."""
|
||||
client = NPMClient(
|
||||
base_url="http://npm:81",
|
||||
email="test@test.com",
|
||||
password="pass"
|
||||
)
|
||||
client._token = "valid_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
with patch.object(client, "_refresh_token", new_callable=AsyncMock) as mock_refresh:
|
||||
await client._ensure_token()
|
||||
mock_refresh.assert_not_called()
|
||||
|
||||
|
||||
class TestNPMClientHealthCheck:
|
||||
"""Test health check functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_true_on_200(self):
|
||||
"""Health check should return True when NPM responds 200."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_true_on_redirect(self):
|
||||
"""Health check should return True on redirect (3xx)."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 302
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_false_on_error(self):
|
||||
"""Health check should return False on connection error."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.side_effect = Exception("Connection refused")
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestNPMClientProxyHosts:
|
||||
"""Test proxy host operations."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_proxy_hosts_returns_list(self):
|
||||
"""get_proxy_hosts should return list of proxy hosts."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
client._token = "test_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
proxy_hosts = [
|
||||
{"id": 1, "domain_names": ["example.com"]},
|
||||
{"id": 2, "domain_names": ["test.com"]}
|
||||
]
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = proxy_hosts
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_proxy_hosts()
|
||||
|
||||
assert result == proxy_hosts
|
||||
assert len(result) == 2
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_proxy_host_returns_single_host(self):
|
||||
"""get_proxy_host should return single proxy host."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
client._token = "test_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
proxy_host = {"id": 1, "domain_names": ["example.com"], "forward_host": "app"}
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = proxy_host
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_proxy_host(1)
|
||||
|
||||
assert result == proxy_host
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_proxy_host_posts_correct_data(self):
|
||||
"""create_proxy_host should POST with correct payload."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
client._token = "test_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"id": 1, "domain_names": ["new.com"]}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.create_proxy_host(
|
||||
domain_names=["new.com"],
|
||||
forward_host="backend",
|
||||
forward_port=8080
|
||||
)
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert call_args[1]["json"]["domain_names"] == ["new.com"]
|
||||
assert call_args[1]["json"]["forward_host"] == "backend"
|
||||
assert call_args[1]["json"]["forward_port"] == 8080
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_proxy_host_puts_correct_data(self):
|
||||
"""update_proxy_host should PUT with correct payload."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
client._token = "test_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
config = {"domain_names": ["updated.com"], "forward_host": "new-backend"}
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.is_success = True
|
||||
mock_response.json.return_value = config
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.put.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.update_proxy_host(1, config)
|
||||
|
||||
assert result == config
|
||||
|
||||
|
||||
class TestNPMClientCertificates:
|
||||
"""Test certificate operations."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_certificates_returns_list(self):
|
||||
"""get_certificates should return list of certificates."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
client._token = "test_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
certificates = [
|
||||
{"id": 1, "domain_names": ["example.com"]},
|
||||
{"id": 2, "domain_names": ["test.com"]}
|
||||
]
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = certificates
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_certificates()
|
||||
|
||||
assert result == certificates
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_certificate_posts_correct_data(self):
|
||||
"""create_certificate should POST with correct payload."""
|
||||
client = NPMClient(base_url="http://npm:81", email="test@test.com", password="pass")
|
||||
client._token = "test_token"
|
||||
client._token_expires = datetime.now() + timedelta(hours=12)
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"id": 1, "domain_names": ["secure.com"]}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.create_certificate(domain_names=["secure.com"])
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert call_args[1]["json"]["domain_names"] == ["secure.com"]
|
||||
assert call_args[1]["json"]["provider"] == "letsencrypt"
|
||||
|
||||
|
||||
class TestNPMClientSingleton:
|
||||
"""Test singleton pattern."""
|
||||
|
||||
def test_returns_same_instance(self):
|
||||
"""get_npm_client should return singleton."""
|
||||
import src.clients.npm_client as module
|
||||
module._npm_client = None
|
||||
|
||||
client1 = get_npm_client()
|
||||
client2 = get_npm_client()
|
||||
|
||||
assert client1 is client2
|
||||
@@ -0,0 +1,167 @@
|
||||
"""Tests for OIDC authentication module."""
|
||||
import pytest
|
||||
from unittest.mock import patch, MagicMock, AsyncMock
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src.auth.oidc import OIDCConfig, oidc_config, get_jwks, get_current_user
|
||||
|
||||
|
||||
class TestOIDCConfig:
|
||||
"""Test OIDCConfig class."""
|
||||
|
||||
def test_init_defaults(self):
|
||||
"""Config should initialize with disabled state."""
|
||||
config = OIDCConfig()
|
||||
|
||||
assert config.enabled is False
|
||||
assert config.issuer == ""
|
||||
assert config.audience == ""
|
||||
assert config.jwks_uri == ""
|
||||
|
||||
def test_configure_sets_values(self):
|
||||
"""configure should set all values."""
|
||||
config = OIDCConfig()
|
||||
config.configure(
|
||||
enabled=True,
|
||||
issuer="https://auth.example.com",
|
||||
audience="core-api"
|
||||
)
|
||||
|
||||
assert config.enabled is True
|
||||
assert config.issuer == "https://auth.example.com"
|
||||
assert config.audience == "core-api"
|
||||
assert config.jwks_uri == "https://auth.example.com/jwks/"
|
||||
|
||||
def test_configure_strips_trailing_slash(self):
|
||||
"""configure should handle trailing slash in issuer."""
|
||||
config = OIDCConfig()
|
||||
config.configure(
|
||||
enabled=True,
|
||||
issuer="https://auth.example.com/",
|
||||
audience="core-api"
|
||||
)
|
||||
|
||||
assert config.jwks_uri == "https://auth.example.com/jwks/"
|
||||
|
||||
|
||||
class TestGetJWKS:
|
||||
"""Test get_jwks function."""
|
||||
|
||||
def test_returns_empty_when_disabled(self):
|
||||
"""get_jwks should return empty dict when OIDC disabled."""
|
||||
# Save original state
|
||||
original_enabled = oidc_config.enabled
|
||||
|
||||
try:
|
||||
oidc_config.enabled = False
|
||||
# Clear the cache
|
||||
get_jwks.cache_clear()
|
||||
|
||||
result = get_jwks()
|
||||
|
||||
assert result == {}
|
||||
finally:
|
||||
# Restore original state
|
||||
oidc_config.enabled = original_enabled
|
||||
get_jwks.cache_clear()
|
||||
|
||||
@patch("src.auth.oidc.httpx.get")
|
||||
def test_fetches_jwks_when_enabled(self, mock_get):
|
||||
"""get_jwks should fetch JWKS when enabled."""
|
||||
# Save original state
|
||||
original_enabled = oidc_config.enabled
|
||||
original_jwks_uri = oidc_config.jwks_uri
|
||||
|
||||
try:
|
||||
oidc_config.enabled = True
|
||||
oidc_config.jwks_uri = "https://auth.example.com/jwks/"
|
||||
get_jwks.cache_clear()
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.json.return_value = {"keys": [{"kid": "test"}]}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
result = get_jwks()
|
||||
|
||||
assert "keys" in result
|
||||
mock_get.assert_called_once()
|
||||
finally:
|
||||
oidc_config.enabled = original_enabled
|
||||
oidc_config.jwks_uri = original_jwks_uri
|
||||
get_jwks.cache_clear()
|
||||
|
||||
@patch("src.auth.oidc.httpx.get")
|
||||
def test_raises_exception_on_error(self, mock_get):
|
||||
"""get_jwks should raise HTTPException on fetch error."""
|
||||
# Save original state
|
||||
original_enabled = oidc_config.enabled
|
||||
original_jwks_uri = oidc_config.jwks_uri
|
||||
|
||||
try:
|
||||
oidc_config.enabled = True
|
||||
oidc_config.jwks_uri = "https://auth.example.com/jwks/"
|
||||
get_jwks.cache_clear()
|
||||
|
||||
mock_get.side_effect = Exception("Connection error")
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
get_jwks()
|
||||
|
||||
assert exc_info.value.status_code == 503
|
||||
finally:
|
||||
oidc_config.enabled = original_enabled
|
||||
oidc_config.jwks_uri = original_jwks_uri
|
||||
get_jwks.cache_clear()
|
||||
|
||||
|
||||
class TestGetCurrentUser:
|
||||
"""Test get_current_user function."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_returns_none_when_disabled(self):
|
||||
"""get_current_user should return None when OIDC disabled."""
|
||||
# Save original state
|
||||
original_enabled = oidc_config.enabled
|
||||
|
||||
try:
|
||||
oidc_config.enabled = False
|
||||
|
||||
result = await get_current_user(credentials=None)
|
||||
|
||||
assert result is None
|
||||
finally:
|
||||
oidc_config.enabled = original_enabled
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_raises_401_when_enabled_without_token(self):
|
||||
"""get_current_user should raise 401 when enabled but no token."""
|
||||
# Save original state
|
||||
original_enabled = oidc_config.enabled
|
||||
|
||||
try:
|
||||
oidc_config.enabled = True
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await get_current_user(credentials=None)
|
||||
|
||||
assert exc_info.value.status_code == 401
|
||||
finally:
|
||||
oidc_config.enabled = original_enabled
|
||||
|
||||
|
||||
class TestOIDCGlobalConfig:
|
||||
"""Test global OIDC config."""
|
||||
|
||||
def test_global_config_exists(self):
|
||||
"""oidc_config should be an OIDCConfig instance."""
|
||||
assert isinstance(oidc_config, OIDCConfig)
|
||||
|
||||
def test_global_config_starts_disabled(self):
|
||||
"""oidc_config should start disabled by default."""
|
||||
# This tests the initial state before any configure() is called
|
||||
# The actual state depends on app configuration
|
||||
assert hasattr(oidc_config, 'enabled')
|
||||
assert hasattr(oidc_config, 'issuer')
|
||||
assert hasattr(oidc_config, 'audience')
|
||||
assert hasattr(oidc_config, 'jwks_uri')
|
||||
@@ -0,0 +1,307 @@
|
||||
"""Tests for Ollama client."""
|
||||
import pytest
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
import json
|
||||
|
||||
from src.models.ollama_client import OllamaClient, get_ollama_client, close_ollama_client
|
||||
|
||||
|
||||
class TestOllamaClientInit:
|
||||
"""Test OllamaClient initialization."""
|
||||
|
||||
@patch("src.models.ollama_client.settings")
|
||||
def test_uses_settings_defaults(self, mock_settings):
|
||||
"""Client should use settings for defaults."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 60
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
assert client.base_url == "http://ollama:11434"
|
||||
assert client.timeout == 60
|
||||
|
||||
@patch("src.models.ollama_client.settings")
|
||||
def test_creates_http_client(self, mock_settings):
|
||||
"""Client should create httpx AsyncClient."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
assert client.client is not None
|
||||
|
||||
|
||||
class TestOllamaClientClose:
|
||||
"""Test client close functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_close_closes_client(self, mock_settings):
|
||||
"""close should close the HTTP client."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
with patch.object(client.client, "aclose", new_callable=AsyncMock) as mock_close:
|
||||
await client.close()
|
||||
mock_close.assert_called_once()
|
||||
|
||||
|
||||
class TestOllamaClientResolveModel:
|
||||
"""Test model resolution."""
|
||||
|
||||
@patch("src.models.ollama_client.settings")
|
||||
def test_resolves_aliased_model(self, mock_settings):
|
||||
"""resolve_model should map alias to actual model."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
mock_settings.model_aliases = {"gpt-3.5-turbo": "gemma:7b"}
|
||||
|
||||
client = OllamaClient()
|
||||
result = client.resolve_model("gpt-3.5-turbo")
|
||||
|
||||
assert result == "gemma:7b"
|
||||
|
||||
@patch("src.models.ollama_client.settings")
|
||||
def test_returns_original_if_no_alias(self, mock_settings):
|
||||
"""resolve_model should return original if no alias found."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
mock_settings.model_aliases = {}
|
||||
|
||||
client = OllamaClient()
|
||||
result = client.resolve_model("llama2")
|
||||
|
||||
assert result == "llama2"
|
||||
|
||||
|
||||
class TestOllamaClientHealthCheck:
|
||||
"""Test health check functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_health_check_returns_true_on_200(self, mock_settings):
|
||||
"""Health check should return True when Ollama responds 200."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is True
|
||||
mock_get.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_health_check_returns_false_on_error(self, mock_settings):
|
||||
"""Health check should return False on connection error."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.side_effect = Exception("Connection refused")
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_health_check_returns_false_on_non_200(self, mock_settings):
|
||||
"""Health check should return False on non-200 status."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 500
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestOllamaClientListModels:
|
||||
"""Test list models functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_list_models_returns_dict(self, mock_settings):
|
||||
"""list_models should return dict with models."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
models_data = {
|
||||
"models": [
|
||||
{"name": "llama2", "size": 1000000},
|
||||
{"name": "gemma:7b", "size": 2000000}
|
||||
]
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = models_data
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.return_value = mock_response
|
||||
result = await client.list_models()
|
||||
|
||||
assert result == models_data
|
||||
assert len(result["models"]) == 2
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_list_models_raises_on_error(self, mock_settings):
|
||||
"""list_models should raise on error."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
with patch.object(client.client, "get", new_callable=AsyncMock) as mock_get:
|
||||
mock_get.side_effect = Exception("Connection error")
|
||||
|
||||
with pytest.raises(Exception):
|
||||
await client.list_models()
|
||||
|
||||
|
||||
class TestOllamaClientGenerateNonStreaming:
|
||||
"""Test non-streaming generation."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_generate_non_streaming_returns_response(self, mock_settings):
|
||||
"""generate_non_streaming should return response dict."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
mock_settings.model_aliases = {}
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
response_data = {
|
||||
"message": {"content": "Hello! How can I help?"},
|
||||
"prompt_eval_count": 10,
|
||||
"eval_count": 20
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = response_data
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.return_value = mock_response
|
||||
result = await client.generate_non_streaming("llama2", "Hello")
|
||||
|
||||
assert result["response"] == "Hello! How can I help?"
|
||||
assert result["tokens"]["prompt"] == 10
|
||||
assert result["tokens"]["completion"] == 20
|
||||
assert result["tokens"]["total"] == 30
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_generate_non_streaming_includes_max_tokens(self, mock_settings):
|
||||
"""generate_non_streaming should include max_tokens in payload."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
mock_settings.model_aliases = {}
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"message": {"content": "Hi"}}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
with patch.object(client.client, "post", new_callable=AsyncMock) as mock_post:
|
||||
mock_post.return_value = mock_response
|
||||
await client.generate_non_streaming("llama2", "Hello", max_tokens=100)
|
||||
|
||||
call_args = mock_post.call_args
|
||||
assert call_args[1]["json"]["options"]["num_predict"] == 100
|
||||
|
||||
|
||||
class TestOllamaClientGenerateStreaming:
|
||||
"""Test streaming generation."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_generate_streaming_yields_content(self, mock_settings):
|
||||
"""generate_streaming should yield content chunks."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
mock_settings.model_aliases = {}
|
||||
|
||||
client = OllamaClient()
|
||||
|
||||
# Create mock streaming response
|
||||
async def mock_aiter_lines():
|
||||
yield json.dumps({"message": {"content": "Hello"}})
|
||||
yield json.dumps({"message": {"content": " world"}})
|
||||
yield json.dumps({"done": True})
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
mock_response.aiter_lines = mock_aiter_lines
|
||||
|
||||
mock_stream_context = AsyncMock()
|
||||
mock_stream_context.__aenter__.return_value = mock_response
|
||||
mock_stream_context.__aexit__.return_value = None
|
||||
|
||||
with patch.object(client.client, "stream", return_value=mock_stream_context):
|
||||
chunks = []
|
||||
async for chunk in client.generate_streaming("llama2", "Hi"):
|
||||
chunks.append(chunk)
|
||||
|
||||
assert "Hello" in chunks
|
||||
assert " world" in chunks
|
||||
|
||||
|
||||
class TestOllamaClientSingleton:
|
||||
"""Test singleton pattern."""
|
||||
|
||||
@patch("src.models.ollama_client.settings")
|
||||
def test_get_ollama_client_returns_same_instance(self, mock_settings):
|
||||
"""get_ollama_client should return singleton."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
import src.models.ollama_client as module
|
||||
module._ollama_client = None
|
||||
|
||||
client1 = get_ollama_client()
|
||||
client2 = get_ollama_client()
|
||||
|
||||
assert client1 is client2
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.models.ollama_client.settings")
|
||||
async def test_close_ollama_client_clears_singleton(self, mock_settings):
|
||||
"""close_ollama_client should clear the singleton."""
|
||||
mock_settings.ollama_base_url = "http://ollama:11434"
|
||||
mock_settings.ollama_timeout = 30
|
||||
|
||||
import src.models.ollama_client as module
|
||||
module._ollama_client = None
|
||||
|
||||
client = get_ollama_client()
|
||||
|
||||
with patch.object(client.client, "aclose", new_callable=AsyncMock):
|
||||
await close_ollama_client()
|
||||
|
||||
assert module._ollama_client is None
|
||||
@@ -0,0 +1,576 @@
|
||||
"""Tests for Portainer client."""
|
||||
import pytest
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
import httpx
|
||||
|
||||
from src.clients.portainer_client import PortainerClient, get_portainer_client
|
||||
|
||||
|
||||
class TestPortainerClientInit:
|
||||
"""Test PortainerClient initialization."""
|
||||
|
||||
@patch("src.clients.portainer_client.settings")
|
||||
def test_uses_settings_defaults(self, mock_settings):
|
||||
"""Client should use settings for defaults."""
|
||||
mock_settings.portainer_url = "http://portainer:9000"
|
||||
mock_settings.portainer_api_key = "test_key"
|
||||
|
||||
client = PortainerClient()
|
||||
|
||||
assert client.base_url == "http://portainer:9000"
|
||||
assert client.api_key == "test_key"
|
||||
|
||||
def test_accepts_custom_url_and_key(self):
|
||||
"""Client should accept custom URL and API key."""
|
||||
client = PortainerClient(
|
||||
base_url="http://custom:9000",
|
||||
api_key="custom_key"
|
||||
)
|
||||
|
||||
assert client.base_url == "http://custom:9000"
|
||||
assert client.api_key == "custom_key"
|
||||
|
||||
def test_strips_trailing_slash_from_url(self):
|
||||
"""Client should strip trailing slash from URL."""
|
||||
client = PortainerClient(
|
||||
base_url="http://custom:9000/",
|
||||
api_key="key"
|
||||
)
|
||||
|
||||
assert client.base_url == "http://custom:9000"
|
||||
|
||||
@patch("src.clients.portainer_client.logger")
|
||||
@patch("src.clients.portainer_client.settings")
|
||||
def test_warns_when_api_key_missing(self, mock_settings, mock_logger):
|
||||
"""Client should warn when API key is not configured."""
|
||||
mock_settings.portainer_url = "http://portainer:9000"
|
||||
mock_settings.portainer_api_key = ""
|
||||
|
||||
PortainerClient()
|
||||
|
||||
mock_logger.warning.assert_called_once()
|
||||
|
||||
|
||||
class TestPortainerClientHeaders:
|
||||
"""Test header generation."""
|
||||
|
||||
def test_get_headers_includes_api_key(self):
|
||||
"""Headers should include X-API-Key."""
|
||||
client = PortainerClient(
|
||||
base_url="http://portainer:9000",
|
||||
api_key="my_api_key"
|
||||
)
|
||||
|
||||
headers = client._get_headers()
|
||||
|
||||
assert headers["X-API-Key"] == "my_api_key"
|
||||
assert headers["Content-Type"] == "application/json"
|
||||
|
||||
|
||||
class TestPortainerClientHealthCheck:
|
||||
"""Test health check functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_true_on_200(self):
|
||||
"""Health check should return True when Portainer responds 200."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_false_on_error(self):
|
||||
"""Health check should return False on connection error."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.side_effect = Exception("Connection refused")
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_health_check_returns_false_on_non_200(self):
|
||||
"""Health check should return False on non-200 status."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 401
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.health_check()
|
||||
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestPortainerClientEndpoints:
|
||||
"""Test endpoint retrieval."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_endpoints_returns_list(self):
|
||||
"""get_endpoints should return list of endpoints."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
endpoints = [
|
||||
{"Id": 1, "Name": "local"},
|
||||
{"Id": 2, "Name": "remote"}
|
||||
]
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = endpoints
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_endpoints()
|
||||
|
||||
assert result == endpoints
|
||||
assert len(result) == 2
|
||||
|
||||
|
||||
class TestPortainerClientStacks:
|
||||
"""Test stack operations."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stacks_returns_list(self):
|
||||
"""get_stacks should return list of stacks."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
stacks = [
|
||||
{"Id": 1, "Name": "stack1", "Status": 1},
|
||||
{"Id": 2, "Name": "stack2", "Status": 1}
|
||||
]
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = stacks
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_stacks()
|
||||
|
||||
assert result == stacks
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stacks_with_endpoint_filter(self):
|
||||
"""get_stacks should filter by endpoint_id when provided."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = []
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.get_stacks(endpoint_id=3)
|
||||
|
||||
# Verify params include endpoint_id
|
||||
call_args = mock_client.get.call_args
|
||||
assert call_args[1]["params"]["endpointId"] == 3
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stack_returns_single_stack(self):
|
||||
"""get_stack should return a single stack."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
stack = {"Id": 1, "Name": "mystack", "Status": 1}
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = stack
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_stack(1)
|
||||
|
||||
assert result == stack
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_stack_posts_correct_data(self):
|
||||
"""create_stack should POST with correct payload."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"Id": 1, "Name": "newstack"}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.create_stack("newstack", "version: '3'\nservices:", 1)
|
||||
|
||||
call_args = mock_client.post.call_args
|
||||
assert call_args[1]["json"]["name"] == "newstack"
|
||||
assert "stackFileContent" in call_args[1]["json"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_stack_puts_correct_data(self):
|
||||
"""update_stack should PUT with correct payload."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {"Id": 1, "Name": "stack"}
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.put.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
await client.update_stack(1, "version: '3'", 1, prune=True, pull_image=True)
|
||||
|
||||
call_args = mock_client.put.call_args
|
||||
assert call_args[1]["json"]["prune"] is True
|
||||
assert call_args[1]["json"]["pullImage"] is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_stack_returns_true(self):
|
||||
"""delete_stack should return True on success."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 204
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.delete.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.delete_stack(1, 1)
|
||||
|
||||
assert result is True
|
||||
|
||||
|
||||
class TestPortainerClientContainers:
|
||||
"""Test container operations."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_containers_returns_list(self):
|
||||
"""get_containers should return list of containers."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
containers = [
|
||||
{"Id": "abc123", "Names": ["/container1"], "State": "running"},
|
||||
{"Id": "def456", "Names": ["/container2"], "State": "exited"}
|
||||
]
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = containers
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_containers(1)
|
||||
|
||||
assert result == containers
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_container_returns_details(self):
|
||||
"""get_container should return container details."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
container = {"Id": "abc123", "Name": "/container1", "State": {"Status": "running"}}
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = container
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.get.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.get_container(1, "abc123")
|
||||
|
||||
assert result == container
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_stop_container_returns_true(self):
|
||||
"""stop_container should return True on success."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 204
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.stop_container(1, "abc123")
|
||||
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_start_container_returns_true(self):
|
||||
"""start_container should return True on success."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncClient") as mock_client_class:
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 204
|
||||
mock_response.raise_for_status = MagicMock()
|
||||
|
||||
mock_client = AsyncMock()
|
||||
mock_client.post.return_value = mock_response
|
||||
mock_client.__aenter__.return_value = mock_client
|
||||
mock_client.__aexit__.return_value = None
|
||||
mock_client_class.return_value = mock_client
|
||||
|
||||
result = await client.start_container(1, "abc123")
|
||||
|
||||
assert result is True
|
||||
|
||||
|
||||
class TestPortainerClientDockerSocketFallback:
|
||||
"""Test Docker socket fallback methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_containers_via_socket_returns_empty_on_error(self):
|
||||
"""_list_containers_via_socket should return empty list on error."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncHTTPTransport") as mock_transport:
|
||||
mock_transport.side_effect = Exception("Socket not available")
|
||||
|
||||
result = await client._list_containers_via_socket()
|
||||
|
||||
assert result == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_inspect_container_via_socket_returns_none_on_error(self):
|
||||
"""_inspect_container_via_socket should return None on error."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch("httpx.AsyncHTTPTransport") as mock_transport:
|
||||
mock_transport.side_effect = Exception("Socket not available")
|
||||
|
||||
result = await client._inspect_container_via_socket("container_name")
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
class TestPortainerClientWrapperMethods:
|
||||
"""Test convenience wrapper methods."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_containers_uses_portainer_first(self):
|
||||
"""list_containers should try Portainer first."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
containers = [{"Id": "abc123", "Names": ["/test"]}]
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.return_value = [{"Id": 1}]
|
||||
|
||||
with patch.object(client, "get_containers", new_callable=AsyncMock) as mock_containers:
|
||||
mock_containers.return_value = containers
|
||||
|
||||
result = await client.list_containers()
|
||||
|
||||
assert result == containers
|
||||
mock_endpoints.assert_called_once()
|
||||
mock_containers.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_containers_falls_back_to_socket(self):
|
||||
"""list_containers should fallback to Docker socket if Portainer returns empty."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.return_value = [{"Id": 1}]
|
||||
|
||||
with patch.object(client, "get_containers", new_callable=AsyncMock) as mock_containers:
|
||||
mock_containers.return_value = []
|
||||
|
||||
with patch.object(client, "_list_containers_via_socket", new_callable=AsyncMock) as mock_socket:
|
||||
mock_socket.return_value = [{"Id": "from_socket"}]
|
||||
|
||||
result = await client.list_containers()
|
||||
|
||||
assert result == [{"Id": "from_socket"}]
|
||||
mock_socket.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_containers_handles_exception_with_fallback(self):
|
||||
"""list_containers should try fallback even on exception."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.side_effect = Exception("API error")
|
||||
|
||||
with patch.object(client, "_list_containers_via_socket", new_callable=AsyncMock) as mock_socket:
|
||||
mock_socket.return_value = [{"Id": "fallback"}]
|
||||
|
||||
result = await client.list_containers()
|
||||
|
||||
assert result == [{"Id": "fallback"}]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_containers_returns_empty_when_all_fails(self):
|
||||
"""list_containers should return empty list when everything fails."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.side_effect = Exception("API error")
|
||||
|
||||
with patch.object(client, "_list_containers_via_socket", new_callable=AsyncMock) as mock_socket:
|
||||
mock_socket.side_effect = Exception("Socket error")
|
||||
|
||||
result = await client.list_containers()
|
||||
|
||||
assert result == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_inspect_container_uses_portainer_first(self):
|
||||
"""inspect_container should try Portainer first."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
container_list = [{"Id": "abc123", "Names": ["/mycontainer"]}]
|
||||
container_detail = {"Id": "abc123", "Name": "/mycontainer", "State": {"Status": "running"}}
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.return_value = [{"Id": 1}]
|
||||
|
||||
with patch.object(client, "get_containers", new_callable=AsyncMock) as mock_list:
|
||||
mock_list.return_value = container_list
|
||||
|
||||
with patch.object(client, "get_container", new_callable=AsyncMock) as mock_detail:
|
||||
mock_detail.return_value = container_detail
|
||||
|
||||
result = await client.inspect_container("mycontainer")
|
||||
|
||||
assert result == container_detail
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_inspect_container_falls_back_to_socket(self):
|
||||
"""inspect_container should fallback if not found in Portainer."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.return_value = [{"Id": 1}]
|
||||
|
||||
with patch.object(client, "get_containers", new_callable=AsyncMock) as mock_list:
|
||||
mock_list.return_value = [] # Container not found
|
||||
|
||||
with patch.object(client, "_inspect_container_via_socket", new_callable=AsyncMock) as mock_socket:
|
||||
mock_socket.return_value = {"Id": "from_socket"}
|
||||
|
||||
result = await client.inspect_container("missing_container")
|
||||
|
||||
assert result == {"Id": "from_socket"}
|
||||
mock_socket.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_inspect_container_handles_exception_with_fallback(self):
|
||||
"""inspect_container should try fallback even on exception."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.side_effect = Exception("API error")
|
||||
|
||||
with patch.object(client, "_inspect_container_via_socket", new_callable=AsyncMock) as mock_socket:
|
||||
mock_socket.return_value = {"Id": "fallback"}
|
||||
|
||||
result = await client.inspect_container("container")
|
||||
|
||||
assert result == {"Id": "fallback"}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_inspect_container_returns_none_when_all_fails(self):
|
||||
"""inspect_container should return None when everything fails."""
|
||||
client = PortainerClient(base_url="http://portainer:9000", api_key="key")
|
||||
|
||||
with patch.object(client, "get_endpoints", new_callable=AsyncMock) as mock_endpoints:
|
||||
mock_endpoints.side_effect = Exception("API error")
|
||||
|
||||
with patch.object(client, "_inspect_container_via_socket", new_callable=AsyncMock) as mock_socket:
|
||||
mock_socket.side_effect = Exception("Socket error")
|
||||
|
||||
result = await client.inspect_container("container")
|
||||
|
||||
assert result is None
|
||||
|
||||
|
||||
class TestPortainerClientSingleton:
|
||||
"""Test singleton pattern."""
|
||||
|
||||
def test_returns_same_instance(self):
|
||||
"""get_portainer_client should return singleton."""
|
||||
# Reset singleton
|
||||
import src.clients.portainer_client as module
|
||||
module._portainer_client = None
|
||||
|
||||
client1 = get_portainer_client()
|
||||
client2 = get_portainer_client()
|
||||
|
||||
assert client1 is client2
|
||||
@@ -0,0 +1,115 @@
|
||||
"""Tests for static controller."""
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from unittest.mock import patch, MagicMock
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
import os
|
||||
|
||||
from src.main import app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client():
|
||||
"""Create a test client."""
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
class TestListWidgets:
|
||||
"""Test /static/widgets endpoint."""
|
||||
|
||||
def test_list_widgets_returns_200(self, client):
|
||||
"""List widgets should return 200."""
|
||||
response = client.get("/static/widgets")
|
||||
assert response.status_code == 200
|
||||
|
||||
def test_list_widgets_returns_widgets_list(self, client):
|
||||
"""List widgets should return widgets array."""
|
||||
response = client.get("/static/widgets")
|
||||
data = response.json()
|
||||
|
||||
assert "widgets" in data
|
||||
assert "count" in data
|
||||
assert isinstance(data["widgets"], list)
|
||||
|
||||
@patch("src.controllers.static_controller.StaticController")
|
||||
def test_list_widgets_handles_missing_directory(self, mock_controller_class, client):
|
||||
"""List widgets should handle missing widgets directory."""
|
||||
# Create a mock controller with non-existent static dir
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
mock_static_dir = Path(tmpdir) / "nonexistent"
|
||||
|
||||
with patch.object(
|
||||
client.app.state if hasattr(client.app, 'state') else client.app,
|
||||
'static_dir',
|
||||
mock_static_dir,
|
||||
create=True
|
||||
):
|
||||
# The actual endpoint handles this case gracefully
|
||||
response = client.get("/static/widgets")
|
||||
# Should still return 200 with empty list or message
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestGetWidget:
|
||||
"""Test /static/widgets/{filename} endpoint."""
|
||||
|
||||
def test_get_widget_returns_404_for_nonexistent(self, client):
|
||||
"""Get widget should return 404 for non-existent file."""
|
||||
response = client.get("/static/widgets/nonexistent-widget.html")
|
||||
assert response.status_code == 404
|
||||
|
||||
def test_get_widget_returns_html_content_type(self, client):
|
||||
"""Get widget should return HTML content type for existing file."""
|
||||
# First check if any widgets exist
|
||||
list_response = client.get("/static/widgets")
|
||||
widgets = list_response.json().get("widgets", [])
|
||||
|
||||
if widgets:
|
||||
# Test with first available widget
|
||||
widget_name = widgets[0]["name"]
|
||||
response = client.get(f"/static/widgets/{widget_name}")
|
||||
assert response.status_code == 200
|
||||
assert "text/html" in response.headers.get("content-type", "")
|
||||
|
||||
def test_get_widget_prevents_path_traversal(self, client):
|
||||
"""Get widget should prevent path traversal attacks."""
|
||||
# Attempt path traversal
|
||||
response = client.get("/static/widgets/../../../etc/passwd")
|
||||
# Should either return 404 or 403, not the actual file
|
||||
assert response.status_code in [400, 403, 404]
|
||||
|
||||
def test_get_widget_includes_cache_headers(self, client):
|
||||
"""Get widget should include no-cache headers."""
|
||||
list_response = client.get("/static/widgets")
|
||||
widgets = list_response.json().get("widgets", [])
|
||||
|
||||
if widgets:
|
||||
widget_name = widgets[0]["name"]
|
||||
response = client.get(f"/static/widgets/{widget_name}")
|
||||
|
||||
if response.status_code == 200:
|
||||
assert "no-cache" in response.headers.get("cache-control", "")
|
||||
|
||||
|
||||
class TestStaticControllerInit:
|
||||
"""Test StaticController initialization."""
|
||||
|
||||
def test_controller_has_static_dir(self):
|
||||
"""Controller should have static directory configured."""
|
||||
from src.controllers.static_controller import static_controller
|
||||
|
||||
assert static_controller.static_dir is not None
|
||||
assert isinstance(static_controller.static_dir, Path)
|
||||
|
||||
def test_controller_has_correct_prefix(self):
|
||||
"""Controller should have /static prefix."""
|
||||
from src.controllers.static_controller import static_controller
|
||||
|
||||
assert static_controller.prefix == "/static"
|
||||
|
||||
def test_controller_has_correct_tags(self):
|
||||
"""Controller should have Static tag."""
|
||||
from src.controllers.static_controller import static_controller
|
||||
|
||||
assert "Static" in static_controller.tags
|
||||
@@ -0,0 +1,142 @@
|
||||
"""Tests for tools controller."""
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
from unittest.mock import patch, AsyncMock, MagicMock
|
||||
|
||||
from src.main import app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client():
|
||||
"""Create a test client."""
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
class TestDNSLookup:
|
||||
"""Test /tools/dns/lookup endpoint."""
|
||||
|
||||
@patch("src.controllers.tools_controller.DNSService")
|
||||
def test_dns_lookup_returns_200(self, mock_dns_class, client):
|
||||
"""DNS lookup should return 200 for valid request."""
|
||||
mock_service = MagicMock()
|
||||
mock_service.lookup = AsyncMock(return_value=MagicMock(
|
||||
success=True,
|
||||
domain="example.com",
|
||||
record_type="A",
|
||||
records=[{"value": "93.184.216.34"}],
|
||||
nameserver_used="8.8.8.8",
|
||||
query_time_ms=50,
|
||||
error_message=None
|
||||
))
|
||||
mock_dns_class.return_value = mock_service
|
||||
|
||||
response = client.post(
|
||||
"/tools/dns/lookup",
|
||||
json={"domain": "example.com", "record_type": "A"}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
@patch("src.controllers.tools_controller.DNSService")
|
||||
def test_dns_lookup_returns_result(self, mock_dns_class, client):
|
||||
"""DNS lookup should return lookup results."""
|
||||
mock_response = MagicMock()
|
||||
mock_response.success = True
|
||||
mock_response.domain = "example.com"
|
||||
mock_response.record_type = "A"
|
||||
mock_response.records = [{"value": "93.184.216.34"}]
|
||||
mock_response.nameserver_used = "8.8.8.8"
|
||||
mock_response.query_time_ms = 50
|
||||
mock_response.error_message = None
|
||||
mock_response.model_dump = MagicMock(return_value={
|
||||
"success": True,
|
||||
"domain": "example.com",
|
||||
"record_type": "A",
|
||||
"records": [{"value": "93.184.216.34"}],
|
||||
"nameserver_used": "8.8.8.8",
|
||||
"query_time_ms": 50,
|
||||
"error_message": None
|
||||
})
|
||||
|
||||
mock_service = MagicMock()
|
||||
mock_service.lookup = AsyncMock(return_value=mock_response)
|
||||
mock_dns_class.return_value = mock_service
|
||||
|
||||
response = client.post(
|
||||
"/tools/dns/lookup",
|
||||
json={"domain": "example.com", "record_type": "A"}
|
||||
)
|
||||
data = response.json()
|
||||
|
||||
assert data["success"] is True
|
||||
assert data["domain"] == "example.com"
|
||||
|
||||
def test_dns_lookup_requires_domain(self, client):
|
||||
"""DNS lookup should require domain parameter."""
|
||||
response = client.post(
|
||||
"/tools/dns/lookup",
|
||||
json={"record_type": "A"}
|
||||
)
|
||||
assert response.status_code == 422
|
||||
|
||||
@patch("src.controllers.tools_controller.DNSService")
|
||||
def test_dns_lookup_handles_dns_query_error(self, mock_dns_class, client):
|
||||
"""DNS lookup should handle DNSQueryError."""
|
||||
from src.dns.exceptions import DNSQueryError
|
||||
|
||||
mock_service = MagicMock()
|
||||
mock_service.lookup = AsyncMock(side_effect=DNSQueryError("Unsupported record type"))
|
||||
mock_dns_class.return_value = mock_service
|
||||
|
||||
response = client.post(
|
||||
"/tools/dns/lookup",
|
||||
json={"domain": "example.com", "record_type": "INVALID"}
|
||||
)
|
||||
assert response.status_code == 400
|
||||
|
||||
|
||||
@patch("src.controllers.tools_controller.DNSService")
|
||||
def test_dns_lookup_accepts_custom_nameserver(self, mock_dns_class, client):
|
||||
"""DNS lookup should accept custom nameserver."""
|
||||
mock_response = MagicMock()
|
||||
mock_response.success = True
|
||||
mock_response.domain = "example.com"
|
||||
mock_response.record_type = "A"
|
||||
mock_response.records = []
|
||||
mock_response.nameserver_used = "1.1.1.1"
|
||||
mock_response.query_time_ms = 30
|
||||
mock_response.error_message = None
|
||||
mock_response.model_dump = MagicMock(return_value={
|
||||
"success": True,
|
||||
"domain": "example.com",
|
||||
"record_type": "A",
|
||||
"records": [],
|
||||
"nameserver_used": "1.1.1.1",
|
||||
"query_time_ms": 30,
|
||||
"error_message": None
|
||||
})
|
||||
|
||||
mock_service = MagicMock()
|
||||
mock_service.lookup = AsyncMock(return_value=mock_response)
|
||||
mock_dns_class.return_value = mock_service
|
||||
|
||||
response = client.post(
|
||||
"/tools/dns/lookup",
|
||||
json={"domain": "example.com", "record_type": "A", "nameserver": "1.1.1.1"}
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
|
||||
class TestToolsControllerInit:
|
||||
"""Test ToolsController initialization."""
|
||||
|
||||
def test_controller_has_correct_prefix(self):
|
||||
"""Controller should have /tools prefix."""
|
||||
from src.controllers.tools_controller import tools_controller
|
||||
|
||||
assert tools_controller.prefix == "/tools"
|
||||
|
||||
def test_controller_has_correct_tags(self):
|
||||
"""Controller should have Tools tag."""
|
||||
from src.controllers.tools_controller import tools_controller
|
||||
|
||||
assert "Tools" in tools_controller.tags
|
||||
Reference in New Issue
Block a user