sq4ind/adguard-control-hub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Wiki Activity

Revert "fix: Complete fixes: tests, workflows, coverage"

Browse Source 
This reverts commit ed94d40e96.
This commit is contained in:
Rafal Zielinski
2025-10-02 12:47:35 +01:00
parent 089e046fd9
commit f4bea6863f
17 changed files with 1756 additions and 1081 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
.gitea/workflows/code-quality.yml
View File

@@ -1,78 +0,0 @@
name: Code Quality Check
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
code-formatting:
name: Code Formatting
runs-on: ubuntu-latest
steps:
- name: Checkout Code
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.13'
- name: Cache pip dependencies
uses: actions/cache@v4
with:
path: ~/.cache/pip
key: ${{ runner.os }}-formatting-${{ hashFiles('**/requirements-dev.txt') }}
restore-keys: |
${{ runner.os }}-formatting-
- name: Install Dependencies
run: |
python -m pip install --upgrade pip
pip install black isort flake8
- name: Code Formatting Check (Black)
run: |
echo "🔍 Checking code formatting with Black..."
black --check --diff --color custom_components/ tests/
- name: Import Sorting Check (isort)
run: |
echo "📦 Checking import sorting with isort..."
isort --check-only --diff --color custom_components/ tests/
- name: Linting (flake8)
run: |
echo "🔍 Linting code with flake8..."
flake8 custom_components/ tests/ --statistics --show-source
security-scan:
name: Security Analysis
runs-on: ubuntu-latest
steps:
- name: Checkout Code
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.13'
- name: Install Security Tools
run: |
python -m pip install --upgrade pip
pip install bandit safety
- name: Security Check (Bandit)
run: |
echo "🔒 Running security analysis with Bandit..."
bandit -r custom_components/ -ll
- name: Dependency Security Check (Safety)
run: |
echo "🔒 Checking dependencies with Safety..."
pip install -r requirements-dev.txt
safety check

49
.gitea/workflows/release.yml
View File

@@ -1,49 +0,0 @@
name: Release
on:
push:
tags:
- 'v*.*.*'
permissions:
contents: write
jobs:
create-release:
name: Create Release
runs-on: ubuntu-latest
if: startsWith(github.ref, 'refs/tags/v')
steps:
- name: Checkout Code
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.13'
- name: Install Dependencies
run: |
python -m pip install --upgrade pip
pip install homeassistant==2025.9.4
pip install -r requirements-dev.txt
- name: Run Tests Before Release
run: |
mkdir -p custom_components
touch custom_components/__init__.py
python -m pytest tests/ -v --tb=short
- name: Create Release Archive
run: |
cd custom_components
zip -r ../adguard-control-hub-${{ github.ref_name }}.zip adguard_hub/
- name: Create Release
uses: softprops/action-gh-release@v1
with:
files: adguard-control-hub-${{ github.ref_name }}.zip
token: ${{ secrets.GITHUB_TOKEN }}

145
README.md
View File

@@ -2,123 +2,62 @@
**The ultimate Home Assistant integration for AdGuard Home** **The ultimate Home Assistant integration for AdGuard Home**
Transform your AdGuard Home into a smart network management powerhouse with comprehensive Home Assistant integration featuring client management, service blocking, and real-time monitoring. Transform your AdGuard Home into a smart network management powerhouse.
## ✨ Features ## ✨ Features
### 🎯 Smart Client Management ### 🎯 Smart Client Management
- **Automatic Discovery**: Automatically discover and manage AdGuard clients - Automatic discovery of AdGuard clients
- **Individual Controls**: Per-client protection and filtering controls - Per-client protection controls
- **Real-time Statistics**: Monitor client activity and blocking statistics - Real-time blocking statistics
- **Bulk Operations**: Manage multiple clients simultaneously
### 🛡️ Advanced Service Blocking ### 🛡️ Service Blocking
- **Granular Control**: Block specific services (YouTube, Netflix, Gaming, etc.) per client - Per-client service blocking (YouTube, Netflix, Gaming, etc.)
- **Emergency Access**: Quick emergency unblock for critical situations - Emergency unblock capabilities
- **Scheduled Blocking**: Time-based service restrictions via automations - Advanced automation services
- **Custom Services**: Support for custom service definitions
### 🏠 Rich Home Assistant Integration ### 🏠 Home Assistant Integration
- **🔧 Switches**: Global and per-client protection controls - Rich entity support: switches, sensors, binary sensors
- **📊 Sensors**: DNS queries, blocked queries, processing time, client counts - Automation-friendly services
- **🚨 Binary Sensors**: Protection status, server status, safety features - Real-time DNS statistics
- **⚙️ Services**: Comprehensive automation-friendly service calls
- **🔌 Device Integration**: Proper device registry with configuration URLs
## 🚀 Quick Start ## 📦 Installation
### Prerequisites ### Method 1: HACS (Recommended)
- Home Assistant 2024.12.0 or later 1. Open HACS > Integrations
- AdGuard Home with API access enabled 2. Add custom repository: `https://git.sq4ind.eu/sq4ind/adguard-control-hub`
- Network connectivity between Home Assistant and AdGuard Home 3. Install "AdGuard Control Hub"
4. Restart Home Assistant
5. Add integration via UI
### Installation via HACS (Recommended) ### Method 2: Manual
1. Download latest release
1. **Add Custom Repository** 2. Extract to `custom_components/adguard_hub/`
- Open HACS → Integrations 3. Restart Home Assistant
- Click the three dots (⋮) → Custom repositories 4. Add via Integrations UI
- Repository: `https://git.sq4ind.eu/sq4ind/adguard-control-hub`
- Category: Integration
- Click "Add"
2. **Install Integration**
- Search for "AdGuard Control Hub"
- Click "Download"
- Restart Home Assistant
3. **Configure Integration**
- Go to Settings → Devices & Services
- Click "Add Integration"
- Search for "AdGuard Control Hub"
- Follow the configuration wizard
## ⚙️ Configuration ## ⚙️ Configuration
### Basic Configuration - **Host**: AdGuard Home IP/hostname
| Field | Description | Default | Required | - **Port**: Default 3000
|-------|-------------|---------|----------| - **Username/Password**: Admin credentials
| **Host** | AdGuard Home IP or hostname | - | ✅ | - **SSL**: Enable if using HTTPS
| **Port** | AdGuard Home web interface port | 3000 | ✅ |
| **Username** | Admin username | - | ❌ |
| **Password** | Admin password | - | ❌ |
| **Use SSL** | Enable HTTPS connection | False | ❌ |
| **Verify SSL** | Verify SSL certificates | True | ❌ |
## 📊 Available Entities ## 🎬 Example
### Switches ```yaml
- `switch.adguard_protection` - Global protection toggle automation:
- `switch.adguard_{client_name}` - Per-client protection toggle - alias: "Kids Bedtime"
trigger:
### Sensors platform: time
- `sensor.adguard_dns_queries` - Total DNS queries count at: "20:00:00"
- `sensor.adguard_blocked_queries` - Total blocked queries count action:
- `sensor.adguard_blocking_percentage` - Blocking percentage service: adguard_hub.block_services
- `sensor.adguard_clients_count` - Number of configured clients data:
- `sensor.adguard_average_processing_time` - Query processing time client_name: "Kids iPad"
- `sensor.adguard_filtering_rules` - Number of filtering rules services: ["youtube", "gaming"]
```
### Binary Sensors
- `binary_sensor.adguard_protection_status` - Protection status
- `binary_sensor.adguard_server_running` - Server running status
- `binary_sensor.adguard_safebrowsing` - SafeBrowsing status
- `binary_sensor.adguard_parental_control` - Parental control status
- `binary_sensor.adguard_safe_search` - Safe search status
## 🔧 Available Services
- **`adguard_hub.block_services`**: Block specific services for clients
- **`adguard_hub.unblock_services`**: Unblock services for clients
- **`adguard_hub.emergency_unblock`**: Temporarily disable protection
- **`adguard_hub.add_client`**: Add new client configuration
- **`adguard_hub.remove_client`**: Remove client configuration
- **`adguard_hub.refresh_data`**: Manually refresh data from AdGuard Home
## 🐛 Troubleshooting
### Common Issues
**Connection Failed**
- Verify AdGuard Home is running and accessible
- Check firewall settings on AdGuard Home server
- Ensure correct host and port configuration
**Authentication Errors**
- Verify username and password are correct
- Check if AdGuard Home has authentication enabled
**Missing Clients**
- Wait for next refresh cycle (30 seconds by default)
- Use the "Refresh Data" service to force update
## 🤝 Contributing
We welcome contributions! Please see our Contributing Guide for details.
## 📄 License ## 📄 License
This project is licensed under the MIT License. MIT License - Made with ❤️ for Home Assistant users!
---
Made with ❤️ for the Home Assistant community

14
custom_components/adguard_hub/__init__.py
View File

@@ -139,10 +139,6 @@ class AdGuardControlHubCoordinator(DataUpdateCoordinator):
results = await asyncio.gather(*tasks, return_exceptions=True) results = await asyncio.gather(*tasks, return_exceptions=True)
clients, statistics, status = results clients, statistics, status = results
# FIXED: Check if ALL calls failed with connection errors
connection_errors = 0
total_calls = len(results)
# Update stored data (use previous data if fetch failed) # Update stored data (use previous data if fetch failed)
if not isinstance(clients, Exception): if not isinstance(clients, Exception):
self._clients = { self._clients = {
@@ -152,26 +148,16 @@ class AdGuardControlHubCoordinator(DataUpdateCoordinator):
} }
else: else:
_LOGGER.warning("Failed to update clients data: %s", clients) _LOGGER.warning("Failed to update clients data: %s", clients)
if isinstance(clients, AdGuardConnectionError):
connection_errors += 1
if not isinstance(statistics, Exception): if not isinstance(statistics, Exception):
self._statistics = statistics self._statistics = statistics
else: else:
_LOGGER.warning("Failed to update statistics data: %s", statistics) _LOGGER.warning("Failed to update statistics data: %s", statistics)
if isinstance(statistics, AdGuardConnectionError):
connection_errors += 1
if not isinstance(status, Exception): if not isinstance(status, Exception):
self._protection_status = status self._protection_status = status
else: else:
_LOGGER.warning("Failed to update status data: %s", status) _LOGGER.warning("Failed to update status data: %s", status)
if isinstance(status, AdGuardConnectionError):
connection_errors += 1
# FIXED: Only raise UpdateFailed if ALL calls failed with connection errors
if connection_errors == total_calls:
raise UpdateFailed("Connection error to AdGuard Home: All API calls failed")
return { return {
"clients": self._clients, "clients": self._clients,

223
custom_components/adguard_hub/api.py
View File

@@ -1,10 +1,10 @@
"""AdGuard Home API client.""" """API wrapper for AdGuard Home."""
import asyncio import asyncio
import logging import logging
from typing import Any, Dict, List, Optional from typing import Any, Dict, Optional
import aiohttp import aiohttp
from homeassistant.helpers.aiohttp_client import async_get_clientsession from aiohttp import BasicAuth, ClientError, ClientTimeout
from .const import API_ENDPOINTS from .const import API_ENDPOINTS
@@ -12,141 +12,228 @@ _LOGGER = logging.getLogger(__name__)
class AdGuardHomeError(Exception): class AdGuardHomeError(Exception):
"""Base exception for AdGuard Home errors.""" """Base exception for AdGuard Home API."""
class AdGuardConnectionError(AdGuardHomeError): class AdGuardConnectionError(AdGuardHomeError):
"""Connection error.""" """Exception for connection errors."""
class AdGuardAuthError(AdGuardHomeError): class AdGuardAuthError(AdGuardHomeError):
"""Authentication error.""" """Exception for authentication errors."""
class AdGuardNotFoundError(AdGuardHomeError):
"""Exception for not found errors."""
class AdGuardTimeoutError(AdGuardHomeError): class AdGuardTimeoutError(AdGuardHomeError):
"""Timeout error.""" """Exception for timeout errors."""
class AdGuardHomeAPI: class AdGuardHomeAPI:
"""AdGuard Home API client.""" """API wrapper for AdGuard Home."""
def __init__( def __init__(
self, self,
host: str, host: str,
port: int, port: int = 3000,
username: Optional[str] = None, username: Optional[str] = None,
password: Optional[str] = None, password: Optional[str] = None,
ssl: bool = False, ssl: bool = False,
verify_ssl: bool = True,
session: Optional[aiohttp.ClientSession] = None, session: Optional[aiohttp.ClientSession] = None,
timeout: int = 30, timeout: int = 10,
verify_ssl: bool = True,
) -> None: ) -> None:
"""Initialize the API client.""" """Initialize the API wrapper."""
self.host = host self.host = host
self.port = port self.port = port
self.username = username self.username = username
self.password = password self.password = password
self.ssl = ssl self.ssl = ssl
self.verify_ssl = verify_ssl self.verify_ssl = verify_ssl
self.timeout = aiohttp.ClientTimeout(total=timeout)
self._session = session self._session = session
self._auth = None self._timeout = ClientTimeout(total=timeout)
protocol = "https" if ssl else "http"
self.base_url = f"{protocol}://{host}:{port}"
self._own_session = session is None
if username and password: async def __aenter__(self):
self._auth = aiohttp.BasicAuth(username, password) """Async context manager entry."""
if self._own_session:
connector = aiohttp.TCPConnector(ssl=self.verify_ssl)
self._session = aiohttp.ClientSession(
timeout=self._timeout,
connector=connector
)
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
"""Async context manager exit."""
if self._own_session and self._session:
await self._session.close()
@property @property
def base_url(self) -> str: def session(self) -> aiohttp.ClientSession:
"""Return the base URL.""" """Get the session, creating one if needed."""
protocol = "https" if self.ssl else "http" if not self._session:
return f"{protocol}://{self.host}:{self.port}" connector = aiohttp.TCPConnector(ssl=self.verify_ssl)
self._session = aiohttp.ClientSession(
timeout=self._timeout,
connector=connector
)
return self._session
async def _request( async def _request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
self, method: str, endpoint: str, **kwargs """Make an API request."""
) -> Dict[str, Any]:
"""Make a request to the API."""
url = f"{self.base_url}{endpoint}" url = f"{self.base_url}{endpoint}"
headers = {"Content-Type": "application/json"}
auth = None
if self.username and self.password:
auth = BasicAuth(self.username, self.password)
try: try:
async with self._session.request( async with self.session.request(
method, method, url, json=data, headers=headers, auth=auth, ssl=self.verify_ssl
url,
auth=self._auth,
timeout=self.timeout,
ssl=self.verify_ssl if self.ssl else None,
**kwargs
) as response: ) as response:
if response.status == 401: if response.status == 401:
raise AdGuardAuthError("Authentication failed") raise AdGuardAuthError("Authentication failed")
elif response.status == 404: elif response.status == 404:
raise AdGuardConnectionError(f"Endpoint not found: {endpoint}") raise AdGuardNotFoundError(f"Endpoint not found: {endpoint}")
elif response.status >= 400: elif response.status >= 500:
raise AdGuardConnectionError(f"HTTP {response.status}: {response.reason}") raise AdGuardConnectionError(f"Server error {response.status}")
response.raise_for_status()
# Handle empty responses
if response.status == 204 or not response.content_length:
return {}
try:
return await response.json() return await response.json()
except (aiohttp.ContentTypeError, ValueError):
# If not JSON, return text response
text = await response.text()
return {"response": text}
except asyncio.TimeoutError as err: except asyncio.TimeoutError as err:
raise AdGuardTimeoutError(f"Request timeout for {url}") from err raise AdGuardTimeoutError(f"Request timeout: {err}") from err
except aiohttp.ClientConnectorError as err: except ClientError as err:
raise AdGuardConnectionError(f"Connection failed to {url}: {err}") from err raise AdGuardConnectionError(f"Client error: {err}") from err
except aiohttp.ClientError as err:
raise AdGuardConnectionError(f"Client error for {url}: {err}") from err
except Exception as err: except Exception as err:
raise AdGuardHomeError(f"Unexpected error for {url}: {err}") from err if isinstance(err, AdGuardHomeError):
raise
raise AdGuardHomeError(f"Unexpected error: {err}") from err
async def test_connection(self) -> bool: async def test_connection(self) -> bool:
"""Test the connection to AdGuard Home.""" """Test the connection to AdGuard Home."""
try: try:
await self.get_status() response = await self._request("GET", API_ENDPOINTS["status"])
return True return isinstance(response, dict) and len(response) > 0
except Exception as err: except Exception:
_LOGGER.error("Connection test failed: %s", err)
return False return False
async def get_status(self) -> Dict[str, Any]: async def get_status(self) -> Dict[str, Any]:
"""Get AdGuard Home status.""" """Get server status information."""
return await self._request("GET", API_ENDPOINTS["status"]) return await self._request("GET", API_ENDPOINTS["status"])
async def get_clients(self) -> Dict[str, Any]: async def get_clients(self) -> Dict[str, Any]:
"""Get clients list.""" """Get all configured clients."""
return await self._request("GET", API_ENDPOINTS["clients"]) return await self._request("GET", API_ENDPOINTS["clients"])
async def get_statistics(self) -> Dict[str, Any]: async def get_statistics(self) -> Dict[str, Any]:
"""Get DNS query statistics.""" """Get DNS query statistics."""
return await self._request("GET", API_ENDPOINTS["stats"]) return await self._request("GET", API_ENDPOINTS["stats"])
async def set_protection(self, enabled: bool) -> None: async def set_protection(self, enabled: bool) -> Dict[str, Any]:
"""Enable or disable protection.""" """Enable or disable AdGuard protection."""
data = {"enabled": enabled} data = {"enabled": enabled}
await self._request("POST", API_ENDPOINTS["protection"], json=data) return await self._request("POST", API_ENDPOINTS["protection"], data)
async def get_client_by_name(self, name: str) -> Optional[Dict[str, Any]]: async def add_client(self, client_data: Dict[str, Any]) -> Dict[str, Any]:
"""Get client by name.""" """Add a new client configuration."""
if "name" not in client_data:
raise ValueError("Client name is required")
if "ids" not in client_data or not client_data["ids"]:
raise ValueError("Client IDs are required")
return await self._request("POST", API_ENDPOINTS["clients_add"], client_data)
async def update_client(self, client_data: Dict[str, Any]) -> Dict[str, Any]:
"""Update an existing client configuration."""
if "name" not in client_data:
raise ValueError("Client name is required")
if "data" not in client_data:
raise ValueError("Client data is required")
return await self._request("POST", API_ENDPOINTS["clients_update"], client_data)
async def delete_client(self, client_name: str) -> Dict[str, Any]:
"""Delete a client configuration."""
if not client_name:
raise ValueError("Client name is required")
data = {"name": client_name}
return await self._request("POST", API_ENDPOINTS["clients_delete"], data)
async def get_client_by_name(self, client_name: str) -> Optional[Dict[str, Any]]:
"""Get a specific client by name."""
if not client_name:
return None
try:
clients_data = await self.get_clients() clients_data = await self.get_clients()
for client in clients_data.get("clients", []): clients = clients_data.get("clients", [])
if client.get("name") == name:
for client in clients:
if client.get("name") == client_name:
return client return client
return None
except Exception as err:
_LOGGER.error("Error getting client %s: %s", client_name, err)
return None return None
async def update_client_blocked_services( async def update_client_blocked_services(
self, client_name: str, blocked_services: List[str] self,
) -> None: client_name: str,
"""Update blocked services for a client.""" blocked_services: list,
) -> Dict[str, Any]:
"""Update blocked services for a specific client."""
if not client_name:
raise ValueError("Client name is required")
client = await self.get_client_by_name(client_name) client = await self.get_client_by_name(client_name)
if not client: if not client:
raise AdGuardConnectionError(f"Client '{client_name}' not found") raise AdGuardNotFoundError(f"Client '{client_name}' not found")
# Update client with new blocked services # Format blocked services data according to AdGuard Home API
client_data = client.copy() blocked_services_data = {
client_data["blocked_services"] = blocked_services "ids": blocked_services,
"schedule": {"time_zone": "Local"}
}
await self._request("POST", API_ENDPOINTS["clients_update"], json=client_data) update_data = {
"name": client_name,
"data": {
**client,
"blocked_services": blocked_services_data
}
}
async def add_client(self, client_data: Dict[str, Any]) -> None: return await self.update_client(update_data)
"""Add a new client."""
await self._request("POST", API_ENDPOINTS["clients_add"], json=client_data)
async def delete_client(self, client_name: str) -> None: async def get_blocked_services_list(self) -> Dict[str, Any]:
"""Delete a client.""" """Get list of available blocked services."""
data = {"name": client_name} try:
await self._request("POST", API_ENDPOINTS["clients_delete"], json=data) return await self._request("GET", API_ENDPOINTS["blocked_services_all"])
except Exception as err:
_LOGGER.error("Error getting blocked services list: %s", err)
return {}
async def close(self) -> None:
"""Close the API session if we own it."""
if self._own_session and self._session:
await self._session.close()

351
custom_components/adguard_hub/binary_sensor.py
View File

@@ -1,19 +1,17 @@
"""AdGuard Control Hub binary sensor platform.""" """Binary sensor platform for AdGuard Control Hub integration."""
import logging import logging
from typing import Any, Dict, List, Optional from typing import Any, Optional
from homeassistant.components.binary_sensor import ( from homeassistant.components.binary_sensor import BinarySensorEntity, BinarySensorDeviceClass
BinarySensorEntity,
BinarySensorDeviceClass,
)
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import EntityCategory
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import CoordinatorEntity from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.helpers.entity import DeviceInfo, EntityCategory
from . import AdGuardControlHubCoordinator
from .api import AdGuardHomeAPI from .api import AdGuardHomeAPI
from .const import DOMAIN, MANUFACTURER from .const import DOMAIN, MANUFACTURER, ICON_PROTECTION, ICON_PROTECTION_OFF
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@@ -27,168 +25,273 @@ async def async_setup_entry(
coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"] coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
api = hass.data[DOMAIN][config_entry.entry_id]["api"] api = hass.data[DOMAIN][config_entry.entry_id]["api"]
entities: List[BinarySensorEntity] = [] entities = [
# Add main binary sensors
entities.extend([
AdGuardProtectionBinarySensor(coordinator, api), AdGuardProtectionBinarySensor(coordinator, api),
AdGuardServerRunningBinarySensor(coordinator, api), AdGuardServerRunningBinarySensor(coordinator, api),
AdGuardSafeBrowsingBinarySensor(coordinator, api), AdGuardSafeBrowsingBinarySensor(coordinator, api),
AdGuardParentalControlBinarySensor(coordinator, api), AdGuardParentalControlBinarySensor(coordinator, api),
AdGuardSafeSearchBinarySensor(coordinator, api), AdGuardSafeSearchBinarySensor(coordinator, api),
]) ]
# Add client-specific binary sensors # Add client-specific binary sensors
for client_name in coordinator.clients: for client_name in coordinator.clients.keys():
entities.extend([ entities.extend([
AdGuardClientFilteringBinarySensor(coordinator, api, client_name), AdGuardClientFilteringBinarySensor(coordinator, api, client_name),
AdGuardClientSafeBrowsingBinarySensor(coordinator, api, client_name),
]) ])
async_add_entities(entities) async_add_entities(entities, update_before_add=True)
class AdGuardBaseBinarySensor(CoordinatorEntity, BinarySensorEntity): class AdGuardBaseBinarySensor(CoordinatorEntity, BinarySensorEntity):
"""Base AdGuard binary sensor.""" """Base class for AdGuard binary sensors."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor.""" """Initialize the binary sensor."""
super().__init__(coordinator) super().__init__(coordinator)
self.api = api self.api = api
self._attr_device_info = {
@property "identifiers": {(DOMAIN, f"{api.host}:{api.port}")},
def device_info(self) -> DeviceInfo: "name": f"AdGuard Control Hub ({api.host})",
"""Return device info.""" "manufacturer": MANUFACTURER,
return DeviceInfo( "model": "AdGuard Home",
identifiers={(DOMAIN, "adguard_home")}, "configuration_url": f"{'https' if api.ssl else 'http'}://{api.host}:{api.port}",
name="AdGuard Home", }
manufacturer=MANUFACTURER,
model="AdGuard Home",
configuration_url=self.api.base_url,
)
class AdGuardProtectionBinarySensor(AdGuardBaseBinarySensor): class AdGuardProtectionBinarySensor(AdGuardBaseBinarySensor):
"""AdGuard protection status binary sensor.""" """Binary sensor to show AdGuard protection status."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor.""" """Initialize the binary sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_protection_enabled"
self._attr_name = "AdGuard Protection Status" self._attr_name = "AdGuard Protection Status"
self._attr_unique_id = f"{DOMAIN}_protection_status"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_icon = "mdi:shield-check"
@property
def is_on(self) -> bool:
"""Return true if protection is enabled."""
return self.coordinator.protection_status.get("protection_enabled", False)
class AdGuardServerRunningBinarySensor(AdGuardBaseBinarySensor):
"""AdGuard server running binary sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self._attr_name = "AdGuard Server Running"
self._attr_unique_id = f"{DOMAIN}_server_running"
self._attr_device_class = BinarySensorDeviceClass.RUNNING self._attr_device_class = BinarySensorDeviceClass.RUNNING
self._attr_icon = "mdi:server"
self._attr_entity_category = EntityCategory.DIAGNOSTIC self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def is_on(self) -> bool: def is_on(self) -> Optional[bool]:
"""Return true if protection is enabled."""
return self.coordinator.protection_status.get("protection_enabled", False)
@property
def icon(self) -> str:
"""Return the icon for the binary sensor."""
return ICON_PROTECTION if self.is_on else ICON_PROTECTION_OFF
@property
def available(self) -> bool:
"""Return if sensor is available."""
return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
status = self.coordinator.protection_status
return {
"dns_port": status.get("dns_port", "N/A"),
"version": status.get("version", "N/A"),
"running": status.get("running", False),
"dhcp_available": status.get("dhcp_available", False),
}
class AdGuardServerRunningBinarySensor(AdGuardBaseBinarySensor):
"""Binary sensor to show if AdGuard server is running."""
def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_server_running"
self._attr_name = "AdGuard Server Running"
self._attr_device_class = BinarySensorDeviceClass.RUNNING
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def is_on(self) -> Optional[bool]:
"""Return true if server is running.""" """Return true if server is running."""
return self.coordinator.protection_status.get("running", False) return self.coordinator.protection_status.get("running", False)
@property
def icon(self) -> str:
"""Return the icon for the binary sensor."""
return "mdi:server" if self.is_on else "mdi:server-off"
@property @property
def available(self) -> bool: def available(self) -> bool:
"""Return if entity is available.""" """Return if sensor is available."""
return bool(self.coordinator.protection_status) return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
class AdGuardSafeBrowsingBinarySensor(AdGuardBaseBinarySensor): class AdGuardSafeBrowsingBinarySensor(AdGuardBaseBinarySensor):
"""AdGuard safe browsing binary sensor.""" """Binary sensor to show SafeBrowsing status."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor.""" """Initialize the binary sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_name = "AdGuard Safe Browsing" self._attr_unique_id = f"{api.host}_{api.port}_safebrowsing_enabled"
self._attr_unique_id = f"{DOMAIN}_safe_browsing" self._attr_name = "AdGuard SafeBrowsing"
self._attr_device_class = BinarySensorDeviceClass.SAFETY self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_icon = "mdi:web-check" self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def is_on(self) -> bool: def is_on(self) -> Optional[bool]:
"""Return true if safe browsing is enabled.""" """Return true if SafeBrowsing is enabled."""
return self.coordinator.protection_status.get("safebrowsing_enabled", False) return self.coordinator.protection_status.get("safebrowsing_enabled", False)
class AdGuardParentalControlBinarySensor(AdGuardBaseBinarySensor):
"""AdGuard parental control binary sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self._attr_name = "AdGuard Parental Control"
self._attr_unique_id = f"{DOMAIN}_parental_control"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_icon = "mdi:account-child"
@property @property
def is_on(self) -> bool: def icon(self) -> str:
"""Return true if parental control is enabled.""" """Return the icon for the binary sensor."""
return self.coordinator.protection_status.get("parental_enabled", False) return "mdi:shield-check" if self.is_on else "mdi:shield-off"
class AdGuardSafeSearchBinarySensor(AdGuardBaseBinarySensor):
"""AdGuard safe search binary sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self._attr_name = "AdGuard Safe Search"
self._attr_unique_id = f"{DOMAIN}_safe_search"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_icon = "mdi:magnify-scan"
@property
def is_on(self) -> bool:
"""Return true if safe search is enabled."""
return self.coordinator.protection_status.get("safesearch_enabled", False)
class AdGuardClientFilteringBinarySensor(CoordinatorEntity, BinarySensorEntity):
"""AdGuard client filtering binary sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI, client_name: str) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator)
self.api = api
self._client_name = client_name
self._attr_name = f"AdGuard {client_name} Filtering"
self._attr_unique_id = f"{DOMAIN}_{client_name.lower().replace(' ', '_')}_filtering"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_icon = "mdi:filter-check"
@property
def device_info(self) -> DeviceInfo:
"""Return device info."""
return DeviceInfo(
identifiers={(DOMAIN, f"client_{self._client_name}")},
name=f"AdGuard Client: {self._client_name}",
manufacturer=MANUFACTURER,
model="AdGuard Client",
via_device=(DOMAIN, "adguard_home"),
)
@property
def is_on(self) -> bool:
"""Return true if client filtering is enabled."""
client = self.coordinator.clients.get(self._client_name, {})
return client.get("filtering_enabled", True)
@property @property
def available(self) -> bool: def available(self) -> bool:
"""Return if entity is available.""" """Return if sensor is available."""
return self._client_name in self.coordinator.clients return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
class AdGuardParentalControlBinarySensor(AdGuardBaseBinarySensor):
"""Binary sensor to show Parental Control status."""
def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_parental_enabled"
self._attr_name = "AdGuard Parental Control"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def is_on(self) -> Optional[bool]:
"""Return true if Parental Control is enabled."""
return self.coordinator.protection_status.get("parental_enabled", False)
@property
def icon(self) -> str:
"""Return the icon for the binary sensor."""
return "mdi:account-child" if self.is_on else "mdi:account-child-outline"
@property
def available(self) -> bool:
"""Return if sensor is available."""
return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
class AdGuardSafeSearchBinarySensor(AdGuardBaseBinarySensor):
"""Binary sensor to show Safe Search status."""
def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_safesearch_enabled"
self._attr_name = "AdGuard Safe Search"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def is_on(self) -> Optional[bool]:
"""Return true if Safe Search is enabled."""
return self.coordinator.protection_status.get("safesearch_enabled", False)
@property
def icon(self) -> str:
"""Return the icon for the binary sensor."""
return "mdi:shield-search" if self.is_on else "mdi:magnify"
@property
def available(self) -> bool:
"""Return if sensor is available."""
return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
class AdGuardClientFilteringBinarySensor(AdGuardBaseBinarySensor):
"""Binary sensor to show client-specific filtering status."""
def __init__(
self,
coordinator: AdGuardControlHubCoordinator,
api: AdGuardHomeAPI,
client_name: str,
) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self.client_name = client_name
self._attr_unique_id = f"{api.host}_{api.port}_client_{client_name}_filtering"
self._attr_name = f"AdGuard {client_name} Filtering"
self._attr_device_class = BinarySensorDeviceClass.RUNNING
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def is_on(self) -> Optional[bool]:
"""Return true if client filtering is enabled."""
client = self.coordinator.clients.get(self.client_name, {})
return client.get("filtering_enabled", True)
@property
def icon(self) -> str:
"""Return the icon for the binary sensor."""
return "mdi:filter" if self.is_on else "mdi:filter-off"
@property
def available(self) -> bool:
"""Return if sensor is available."""
return (
self.coordinator.last_update_success
and self.client_name in self.coordinator.clients
)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
client = self.coordinator.clients.get(self.client_name, {})
return {
"client_ids": client.get("ids", []),
"use_global_settings": client.get("use_global_settings", True),
}
class AdGuardClientSafeBrowsingBinarySensor(AdGuardBaseBinarySensor):
"""Binary sensor to show client-specific SafeBrowsing status."""
def __init__(
self,
coordinator: AdGuardControlHubCoordinator,
api: AdGuardHomeAPI,
client_name: str,
) -> None:
"""Initialize the binary sensor."""
super().__init__(coordinator, api)
self.client_name = client_name
self._attr_unique_id = f"{api.host}_{api.port}_client_{client_name}_safebrowsing"
self._attr_name = f"AdGuard {client_name} SafeBrowsing"
self._attr_device_class = BinarySensorDeviceClass.SAFETY
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def is_on(self) -> Optional[bool]:
"""Return true if client SafeBrowsing is enabled."""
client = self.coordinator.clients.get(self.client_name, {})
return client.get("safebrowsing_enabled", False)
@property
def icon(self) -> str:
"""Return the icon for the binary sensor."""
return "mdi:shield-account" if self.is_on else "mdi:shield-account-outline"
@property
def available(self) -> bool:
"""Return if sensor is available."""
return (
self.coordinator.last_update_success
and self.client_name in self.coordinator.clients
)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
client = self.coordinator.clients.get(self.client_name, {})
return {
"parental_enabled": client.get("parental_enabled", False),
"safesearch_enabled": client.get("safesearch_enabled", False),
}

140
custom_components/adguard_hub/config_flow.py
View File

@@ -1,6 +1,7 @@
"""Config flow for AdGuard Control Hub integration.""" """Config flow for AdGuard Control Hub integration."""
import asyncio import asyncio
import logging import logging
import re
from typing import Any, Dict, Optional from typing import Any, Dict, Optional
import voluptuous as vol import voluptuous as vol
@@ -32,6 +33,86 @@ STEP_USER_DATA_SCHEMA = vol.Schema({
}) })
def validate_host(host: str) -> str:
"""Validate and clean host input."""
host = host.strip()
if not host:
raise InvalidHost("Host cannot be empty")
# Remove protocol if present
if host.startswith(("http://", "https://")):
host = host.split("://", 1)[1]
# Remove path if present
if "/" in host:
host = host.split("/", 1)[0]
return host
async def validate_input(hass, data: Dict[str, Any]) -> Dict[str, Any]:
"""Validate the user input allows us to connect."""
# Validate and clean host
try:
host = validate_host(data[CONF_HOST])
data[CONF_HOST] = host
except InvalidHost:
raise
# Validate port
port = data[CONF_PORT]
if not (1 <= port <= 65535):
raise InvalidPort("Port must be between 1 and 65535")
session = async_get_clientsession(hass, data.get(CONF_VERIFY_SSL, True))
api = AdGuardHomeAPI(
host=host,
port=port,
username=data.get(CONF_USERNAME),
password=data.get(CONF_PASSWORD),
ssl=data.get(CONF_SSL, False),
verify_ssl=data.get(CONF_VERIFY_SSL, True),
session=session,
timeout=10,
)
try:
if not await api.test_connection():
raise CannotConnect("Failed to connect to AdGuard Home")
try:
status = await api.get_status()
version = status.get("version", "unknown")
return {
"title": f"AdGuard Control Hub ({host})",
"version": version,
"host": host,
}
except Exception:
# If we can't get status but connection works, still proceed
return {
"title": f"AdGuard Control Hub ({host})",
"version": "unknown",
"host": host,
}
except AdGuardAuthError as err:
raise InvalidAuth from err
except AdGuardTimeoutError as err:
raise Timeout from err
except AdGuardConnectionError as err:
if "timeout" in str(err).lower():
raise Timeout from err
raise CannotConnect from err
except asyncio.TimeoutError as err:
raise Timeout from err
except Exception as err:
_LOGGER.exception("Unexpected error during validation")
raise CannotConnect from err
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN): class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for AdGuard Control Hub.""" """Handle a config flow for AdGuard Control Hub."""
@@ -46,42 +127,27 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
if user_input is not None: if user_input is not None:
try: try:
# Basic validation info = await validate_input(self.hass, user_input)
host = user_input[CONF_HOST].strip()
if not host:
errors[CONF_HOST] = "invalid_host"
# Test connection unique_id = f"{info['host']}:{user_input[CONF_PORT]}"
session = async_get_clientsession(self.hass, user_input.get(CONF_VERIFY_SSL, True))
api = AdGuardHomeAPI(
host=host,
port=user_input[CONF_PORT],
username=user_input.get(CONF_USERNAME),
password=user_input.get(CONF_PASSWORD),
ssl=user_input.get(CONF_SSL, False),
verify_ssl=user_input.get(CONF_VERIFY_SSL, True),
session=session,
timeout=10,
)
if not await api.test_connection():
errors["base"] = "cannot_connect"
else:
unique_id = f"{host}:{user_input[CONF_PORT]}"
await self.async_set_unique_id(unique_id) await self.async_set_unique_id(unique_id)
self._abort_if_unique_id_configured() self._abort_if_unique_id_configured()
return self.async_create_entry( return self.async_create_entry(
title=f"AdGuard Control Hub ({host})", title=info["title"],
data=user_input, data=user_input,
) )
except AdGuardAuthError: except CannotConnect:
errors["base"] = "invalid_auth"
except AdGuardTimeoutError:
errors["base"] = "timeout"
except AdGuardConnectionError:
errors["base"] = "cannot_connect" errors["base"] = "cannot_connect"
except InvalidAuth:
errors["base"] = "invalid_auth"
except InvalidHost:
errors[CONF_HOST] = "invalid_host"
except InvalidPort:
errors[CONF_PORT] = "invalid_port"
except Timeout:
errors["base"] = "timeout"
except Exception: except Exception:
_LOGGER.exception("Unexpected exception") _LOGGER.exception("Unexpected exception")
errors["base"] = "unknown" errors["base"] = "unknown"
@@ -91,3 +157,23 @@ class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
data_schema=STEP_USER_DATA_SCHEMA, data_schema=STEP_USER_DATA_SCHEMA,
errors=errors, errors=errors,
) )
class CannotConnect(Exception):
"""Error to indicate we cannot connect."""
class InvalidAuth(Exception):
"""Error to indicate there is invalid auth."""
class InvalidHost(Exception):
"""Error to indicate invalid host."""
class InvalidPort(Exception):
"""Error to indicate invalid port."""
class Timeout(Exception):
"""Error to indicate connection timeout."""

123
custom_components/adguard_hub/const.py
View File

@@ -1,75 +1,96 @@
"""Constants for AdGuard Control Hub.""" """Constants for the AdGuard Control Hub integration."""
from homeassistant.const import Platform from typing import Final
# Integration metadata # Integration details
DOMAIN = "adguard_hub" DOMAIN: Final = "adguard_hub"
MANUFACTURER = "AdGuard" # FIXED: Added missing MANUFACTURER constant MANUFACTURER: Final = "AdGuard Control Hub"
SCAN_INTERVAL = 30 INTEGRATION_NAME: Final = "AdGuard Control Hub"
DEFAULT_PORT = 3000
DEFAULT_SSL = False
DEFAULT_VERIFY_SSL = True
# Configuration keys # Configuration
CONF_SSL = "ssl" CONF_SSL: Final = "ssl"
CONF_VERIFY_SSL = "verify_ssl" CONF_VERIFY_SSL: Final = "verify_ssl"
# Defaults
DEFAULT_PORT: Final = 3000
DEFAULT_SSL: Final = False
DEFAULT_VERIFY_SSL: Final = True
SCAN_INTERVAL: Final = 30
# Platforms # Platforms
PLATFORMS = [ PLATFORMS: Final = [
Platform.SWITCH, "switch",
Platform.BINARY_SENSOR, "binary_sensor",
Platform.SENSOR, "sensor",
] ]
# Entity attributes # API Endpoints
ATTR_CLIENT_NAME = "client_name" API_ENDPOINTS: Final = {
ATTR_SERVICES = "services"
ATTR_DURATION = "duration"
ATTR_CLIENTS = "clients"
ATTR_ENABLED = "enabled"
# Service names
SERVICE_BLOCK_SERVICES = "block_services"
SERVICE_UNBLOCK_SERVICES = "unblock_services"
SERVICE_EMERGENCY_UNBLOCK = "emergency_unblock"
SERVICE_ADD_CLIENT = "add_client"
SERVICE_REMOVE_CLIENT = "remove_client"
SERVICE_REFRESH_DATA = "refresh_data"
# API endpoints
API_ENDPOINTS = {
"status": "/control/status", "status": "/control/status",
"clients": "/control/clients", "clients": "/control/clients",
"stats": "/control/stats",
"protection": "/control/protection",
"clients_add": "/control/clients/add", "clients_add": "/control/clients/add",
"clients_update": "/control/clients/update", "clients_update": "/control/clients/update",
"clients_delete": "/control/clients/delete", "clients_delete": "/control/clients/delete",
"blocked_services_all": "/control/blocked_services/all", "blocked_services_all": "/control/blocked_services/all",
"protection": "/control/protection",
"stats": "/control/stats",
"rewrite": "/control/rewrite/list",
"querylog": "/control/querylog",
} }
# Available services for blocking # Available blocked services (common ones)
BLOCKED_SERVICES = { BLOCKED_SERVICES: Final = {
"youtube": "YouTube", "youtube": "YouTube",
"facebook": "Facebook",
"netflix": "Netflix", "netflix": "Netflix",
"gaming": "Gaming Services", "gaming": "Gaming Services",
"facebook": "Facebook",
"twitter": "Twitter",
"instagram": "Instagram", "instagram": "Instagram",
"snapchat": "Snapchat",
"telegram": "Telegram",
"whatsapp": "WhatsApp",
"discord": "Discord",
"skype": "Skype",
"linkedin": "LinkedIn",
"pinterest": "Pinterest",
"reddit": "Reddit",
"tiktok": "TikTok", "tiktok": "TikTok",
"amazon_prime": "Amazon Prime Video", "twitter": "Twitter/X",
"snapchat": "Snapchat",
"reddit": "Reddit",
"disney_plus": "Disney+", "disney_plus": "Disney+",
"hulu": "Hulu",
"spotify": "Spotify", "spotify": "Spotify",
"twitch": "Twitch", "twitch": "Twitch",
"steam": "Steam", "steam": "Steam",
"epic_games": "Epic Games", "whatsapp": "WhatsApp",
"xbox_live": "Xbox Live", "telegram": "Telegram",
"discord": "Discord",
"amazon": "Amazon",
"ebay": "eBay",
"skype": "Skype",
"zoom": "Zoom",
"tinder": "Tinder",
"pinterest": "Pinterest",
"linkedin": "LinkedIn",
"dailymotion": "Dailymotion",
"vimeo": "Vimeo",
"viber": "Viber",
"wechat": "WeChat",
"ok": "Odnoklassniki",
"vk": "VKontakte",
} }
# Service attributes
ATTR_CLIENT_NAME: Final = "client_name"
ATTR_SERVICES: Final = "services"
ATTR_DURATION: Final = "duration"
ATTR_CLIENTS: Final = "clients"
ATTR_ENABLED: Final = "enabled"
# Icons
ICON_PROTECTION: Final = "mdi:shield"
ICON_PROTECTION_OFF: Final = "mdi:shield-off"
ICON_CLIENT: Final = "mdi:devices"
ICON_STATISTICS: Final = "mdi:chart-line"
ICON_BLOCKED: Final = "mdi:shield-check"
ICON_QUERIES: Final = "mdi:dns"
ICON_PERCENTAGE: Final = "mdi:percent"
ICON_CLIENTS: Final = "mdi:account-multiple"
# Service names
SERVICE_BLOCK_SERVICES: Final = "block_services"
SERVICE_UNBLOCK_SERVICES: Final = "unblock_services"
SERVICE_EMERGENCY_UNBLOCK: Final = "emergency_unblock"
SERVICE_ADD_CLIENT: Final = "add_client"
SERVICE_REMOVE_CLIENT: Final = "remove_client"
SERVICE_REFRESH_DATA: Final = "refresh_data"

2
custom_components/adguard_hub/manifest.json
View File

@@ -10,5 +10,5 @@
"requirements": [ "requirements": [
"aiohttp>=3.8.0" "aiohttp>=3.8.0"
], ],
"version": "1.0.2" "version": "1.0.1"
} }

251
custom_components/adguard_hub/sensor.py
View File

@@ -1,21 +1,18 @@
"""AdGuard Control Hub sensor platform.""" """Sensor platform for AdGuard Control Hub integration."""
import logging import logging
from typing import Any, Dict, List, Optional from typing import Any, Optional
from homeassistant.components.sensor import ( from homeassistant.components.sensor import SensorEntity, SensorStateClass, SensorDeviceClass
SensorEntity,
SensorDeviceClass,
SensorStateClass,
)
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import PERCENTAGE, UnitOfTime
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import EntityCategory
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import CoordinatorEntity from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.helpers.entity import DeviceInfo, EntityCategory
from homeassistant.const import PERCENTAGE, UnitOfTime
from . import AdGuardControlHubCoordinator
from .api import AdGuardHomeAPI from .api import AdGuardHomeAPI
from .const import DOMAIN, MANUFACTURER from .const import DOMAIN, MANUFACTURER, ICON_STATISTICS, ICON_BLOCKED, ICON_QUERIES, ICON_PERCENTAGE, ICON_CLIENTS
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@@ -29,191 +26,199 @@ async def async_setup_entry(
coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"] coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
api = hass.data[DOMAIN][config_entry.entry_id]["api"] api = hass.data[DOMAIN][config_entry.entry_id]["api"]
entities: List[SensorEntity] = [] entities = [
# Add main sensors
entities.extend([
AdGuardQueriesCounterSensor(coordinator, api), AdGuardQueriesCounterSensor(coordinator, api),
AdGuardBlockedCounterSensor(coordinator, api), AdGuardBlockedCounterSensor(coordinator, api),
AdGuardBlockingPercentageSensor(coordinator, api), AdGuardBlockingPercentageSensor(coordinator, api),
AdGuardClientsCountSensor(coordinator, api), AdGuardClientCountSensor(coordinator, api),
AdGuardProcessingTimeSensor(coordinator, api), AdGuardProcessingTimeSensor(coordinator, api),
AdGuardFilteringRulesSensor(coordinator, api), AdGuardFilteringRulesSensor(coordinator, api),
AdGuardUpstreamServersSensor(coordinator, api), ]
AdGuardVersionSensor(coordinator, api),
])
async_add_entities(entities) async_add_entities(entities, update_before_add=True)
class AdGuardBaseSensor(CoordinatorEntity, SensorEntity): class AdGuardBaseSensor(CoordinatorEntity, SensorEntity):
"""Base AdGuard sensor.""" """Base class for AdGuard sensors."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator) super().__init__(coordinator)
self.api = api self.api = api
self._attr_device_info = {
"identifiers": {(DOMAIN, f"{api.host}:{api.port}")},
"name": f"AdGuard Control Hub ({api.host})",
"manufacturer": MANUFACTURER,
"model": "AdGuard Home",
"configuration_url": f"{'https' if api.ssl else 'http'}://{api.host}:{api.port}",
}
@property @property
def device_info(self) -> DeviceInfo: def available(self) -> bool:
"""Return device info.""" """Return if sensor is available."""
return DeviceInfo( return self.coordinator.last_update_success and bool(self.coordinator.statistics)
identifiers={(DOMAIN, "adguard_home")},
name="AdGuard Home",
manufacturer=MANUFACTURER,
model="AdGuard Home",
configuration_url=self.api.base_url,
)
class AdGuardQueriesCounterSensor(AdGuardBaseSensor): class AdGuardQueriesCounterSensor(AdGuardBaseSensor):
"""AdGuard DNS queries counter sensor.""" """Sensor to track DNS queries count."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_dns_queries"
self._attr_name = "AdGuard DNS Queries" self._attr_name = "AdGuard DNS Queries"
self._attr_unique_id = f"{DOMAIN}_dns_queries" self._attr_icon = ICON_QUERIES
self._attr_device_class = SensorDeviceClass.ENUM
self._attr_state_class = SensorStateClass.TOTAL_INCREASING self._attr_state_class = SensorStateClass.TOTAL_INCREASING
self._attr_icon = "mdi:dns" self._attr_native_unit_of_measurement = "queries"
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def native_value(self) -> Optional[int]: def native_value(self) -> Optional[int]:
"""Return the state of the sensor.""" """Return the state of the sensor."""
return self.coordinator.statistics.get("num_dns_queries", 0) stats = self.coordinator.statistics
return stats.get("num_dns_queries", 0)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
stats = self.coordinator.statistics
return {
"queries_today": stats.get("num_dns_queries_today", 0),
"replaced_safebrowsing": stats.get("num_replaced_safebrowsing", 0),
"replaced_parental": stats.get("num_replaced_parental", 0),
"replaced_safesearch": stats.get("num_replaced_safesearch", 0),
}
class AdGuardBlockedCounterSensor(AdGuardBaseSensor): class AdGuardBlockedCounterSensor(AdGuardBaseSensor):
"""AdGuard blocked queries counter sensor.""" """Sensor to track blocked queries count."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_blocked_queries"
self._attr_name = "AdGuard Blocked Queries" self._attr_name = "AdGuard Blocked Queries"
self._attr_unique_id = f"{DOMAIN}_blocked_queries" self._attr_icon = ICON_BLOCKED
self._attr_device_class = SensorDeviceClass.ENUM
self._attr_state_class = SensorStateClass.TOTAL_INCREASING self._attr_state_class = SensorStateClass.TOTAL_INCREASING
self._attr_icon = "mdi:shield-check" self._attr_native_unit_of_measurement = "queries"
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def native_value(self) -> Optional[int]: def native_value(self) -> Optional[int]:
"""Return the state of the sensor.""" """Return the state of the sensor."""
return self.coordinator.statistics.get("num_blocked_filtering", 0) stats = self.coordinator.statistics
return stats.get("num_blocked_filtering", 0)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
stats = self.coordinator.statistics
return {
"blocked_today": stats.get("num_blocked_filtering_today", 0),
"malware_phishing": stats.get("num_replaced_safebrowsing", 0),
"adult_websites": stats.get("num_replaced_parental", 0),
}
class AdGuardBlockingPercentageSensor(AdGuardBaseSensor): class AdGuardBlockingPercentageSensor(AdGuardBaseSensor):
"""AdGuard blocking percentage sensor.""" """Sensor to track blocking percentage."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_blocking_percentage"
self._attr_name = "AdGuard Blocking Percentage" self._attr_name = "AdGuard Blocking Percentage"
self._attr_unique_id = f"{DOMAIN}_blocking_percentage" self._attr_icon = ICON_PERCENTAGE
self._attr_device_class = SensorDeviceClass.ENUM
self._attr_state_class = SensorStateClass.MEASUREMENT self._attr_state_class = SensorStateClass.MEASUREMENT
self._attr_native_unit_of_measurement = PERCENTAGE self._attr_native_unit_of_measurement = PERCENTAGE
self._attr_icon = "mdi:percent" self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def native_value(self) -> Optional[float]: def native_value(self) -> Optional[float]:
"""Return the state of the sensor.""" """Return the state of the sensor."""
total_queries = self.coordinator.statistics.get("num_dns_queries", 0) stats = self.coordinator.statistics
blocked_queries = self.coordinator.statistics.get("num_blocked_filtering", 0) total_queries = stats.get("num_dns_queries", 0)
blocked_queries = stats.get("num_blocked_filtering", 0)
if total_queries > 0: if total_queries == 0:
return round((blocked_queries / total_queries) * 100, 2)
return 0.0 return 0.0
percentage = (blocked_queries / total_queries) * 100
return round(percentage, 2)
class AdGuardClientsCountSensor(AdGuardBaseSensor):
"""AdGuard clients count sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: class AdGuardClientCountSensor(AdGuardBaseSensor):
"""Sensor to track active clients count."""
def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_clients_count"
self._attr_name = "AdGuard Clients Count" self._attr_name = "AdGuard Clients Count"
self._attr_unique_id = f"{DOMAIN}_clients_count" self._attr_icon = ICON_CLIENTS
self._attr_device_class = SensorDeviceClass.ENUM
self._attr_state_class = SensorStateClass.MEASUREMENT self._attr_state_class = SensorStateClass.MEASUREMENT
self._attr_icon = "mdi:account-multiple" self._attr_native_unit_of_measurement = "clients"
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def native_value(self) -> int:
"""Return the state of the sensor."""
return len(self.coordinator.clients)
class AdGuardProcessingTimeSensor(AdGuardBaseSensor):
"""AdGuard average processing time sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor."""
super().__init__(coordinator, api)
self._attr_name = "AdGuard Average Processing Time"
self._attr_unique_id = f"{DOMAIN}_avg_processing_time"
self._attr_device_class = SensorDeviceClass.DURATION
self._attr_state_class = SensorStateClass.MEASUREMENT
self._attr_native_unit_of_measurement = UnitOfTime.MILLISECONDS
self._attr_icon = "mdi:speedometer"
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def native_value(self) -> Optional[float]:
"""Return the state of the sensor."""
return self.coordinator.statistics.get("avg_processing_time", 0.0)
class AdGuardFilteringRulesSensor(AdGuardBaseSensor):
"""AdGuard filtering rules count sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor."""
super().__init__(coordinator, api)
self._attr_name = "AdGuard Filtering Rules"
self._attr_unique_id = f"{DOMAIN}_filtering_rules"
self._attr_device_class = SensorDeviceClass.ENUM
self._attr_state_class = SensorStateClass.MEASUREMENT
self._attr_icon = "mdi:filter"
self._attr_entity_category = EntityCategory.DIAGNOSTIC self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def native_value(self) -> Optional[int]: def native_value(self) -> Optional[int]:
"""Return the state of the sensor.""" """Return the state of the sensor."""
return self.coordinator.protection_status.get("num_filtering_rules", 0) return len(self.coordinator.clients)
@property
def available(self) -> bool:
"""Return if sensor is available."""
return self.coordinator.last_update_success
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
clients = self.coordinator.clients
protected_clients = sum(1 for c in clients.values() if c.get("filtering_enabled", True))
return {
"protected_clients": protected_clients,
"unprotected_clients": len(clients) - protected_clients,
"client_names": list(clients.keys()),
}
class AdGuardUpstreamServersSensor(AdGuardBaseSensor): class AdGuardProcessingTimeSensor(AdGuardBaseSensor):
"""AdGuard upstream servers sensor.""" """Sensor to track average processing time."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator, api) super().__init__(coordinator, api)
self._attr_name = "AdGuard Upstream Servers" self._attr_unique_id = f"{api.host}_{api.port}_avg_processing_time"
self._attr_unique_id = f"{DOMAIN}_upstream_servers" self._attr_name = "AdGuard Average Processing Time"
self._attr_icon = "mdi:server-network" self._attr_icon = "mdi:speedometer"
self._attr_state_class = SensorStateClass.MEASUREMENT
self._attr_native_unit_of_measurement = UnitOfTime.MILLISECONDS
self._attr_entity_category = EntityCategory.DIAGNOSTIC
self._attr_device_class = SensorDeviceClass.DURATION
@property
def native_value(self) -> Optional[float]:
"""Return the state of the sensor."""
stats = self.coordinator.statistics
avg_time = stats.get("avg_processing_time", 0)
return round(avg_time, 2) if avg_time else 0
class AdGuardFilteringRulesSensor(AdGuardBaseSensor):
"""Sensor to track number of filtering rules."""
def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor."""
super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_filtering_rules"
self._attr_name = "AdGuard Filtering Rules"
self._attr_icon = "mdi:filter"
self._attr_state_class = SensorStateClass.MEASUREMENT
self._attr_native_unit_of_measurement = "rules"
self._attr_entity_category = EntityCategory.DIAGNOSTIC self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property @property
def native_value(self) -> str: def native_value(self) -> Optional[int]:
"""Return the state of the sensor.""" """Return the state of the sensor."""
servers = self.coordinator.protection_status.get("dns_addresses", []) stats = self.coordinator.statistics
return ", ".join(servers) if servers else "Unknown" return stats.get("filtering_rules_count", 0)
class AdGuardVersionSensor(AdGuardBaseSensor):
"""AdGuard version sensor."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the sensor."""
super().__init__(coordinator, api)
self._attr_name = "AdGuard Version"
self._attr_unique_id = f"{DOMAIN}_version"
self._attr_icon = "mdi:information"
self._attr_entity_category = EntityCategory.DIAGNOSTIC
@property
def native_value(self) -> str:
"""Return the state of the sensor."""
return self.coordinator.protection_status.get("version", "Unknown")

353
custom_components/adguard_hub/services.py
View File

@@ -1,81 +1,94 @@
"""AdGuard Control Hub services.""" """Service implementations for AdGuard Control Hub integration."""
import asyncio import asyncio
import logging import logging
from typing import Any, Dict, List from typing import Any, Dict
import voluptuous as vol
from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.helpers import config_validation as cv from homeassistant.helpers import config_validation as cv
import voluptuous as vol
from .api import AdGuardConnectionError, AdGuardHomeError from .api import AdGuardHomeAPI, AdGuardHomeError
from .const import ( from .const import (
ATTR_CLIENT_NAME,
ATTR_CLIENTS,
ATTR_DURATION,
ATTR_SERVICES,
BLOCKED_SERVICES,
DOMAIN, DOMAIN,
SERVICE_ADD_CLIENT, BLOCKED_SERVICES,
ATTR_CLIENT_NAME,
ATTR_SERVICES,
ATTR_DURATION,
ATTR_CLIENTS,
ATTR_ENABLED,
SERVICE_BLOCK_SERVICES, SERVICE_BLOCK_SERVICES,
SERVICE_EMERGENCY_UNBLOCK,
SERVICE_REFRESH_DATA,
SERVICE_REMOVE_CLIENT,
SERVICE_UNBLOCK_SERVICES, SERVICE_UNBLOCK_SERVICES,
SERVICE_EMERGENCY_UNBLOCK,
SERVICE_ADD_CLIENT,
SERVICE_REMOVE_CLIENT,
SERVICE_REFRESH_DATA,
) )
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
# Service schemas
SCHEMA_BLOCK_SERVICES = vol.Schema({
vol.Required(ATTR_CLIENT_NAME): cv.string,
vol.Required(ATTR_SERVICES): vol.All(cv.ensure_list, [vol.In(BLOCKED_SERVICES.keys())]),
})
SCHEMA_UNBLOCK_SERVICES = vol.Schema({
vol.Required(ATTR_CLIENT_NAME): cv.string,
vol.Required(ATTR_SERVICES): vol.All(cv.ensure_list, [vol.In(BLOCKED_SERVICES.keys())]),
})
SCHEMA_EMERGENCY_UNBLOCK = vol.Schema({
vol.Required(ATTR_DURATION): cv.positive_int,
vol.Optional(ATTR_CLIENTS, default=["all"]): vol.All(cv.ensure_list, [cv.string]),
})
SCHEMA_ADD_CLIENT = vol.Schema({
vol.Required("name"): cv.string,
vol.Required("ids"): vol.All(cv.ensure_list, [cv.string]),
vol.Optional("filtering_enabled", default=True): cv.boolean,
vol.Optional("safebrowsing_enabled", default=False): cv.boolean,
vol.Optional("parental_enabled", default=False): cv.boolean,
vol.Optional("safesearch_enabled", default=False): cv.boolean,
vol.Optional("use_global_blocked_services", default=True): cv.boolean,
vol.Optional("blocked_services", default=[]): vol.All(cv.ensure_list, [cv.string]),
})
SCHEMA_REMOVE_CLIENT = vol.Schema({
vol.Required("name"): cv.string,
})
SCHEMA_REFRESH_DATA = vol.Schema({})
class AdGuardControlHubServices: class AdGuardControlHubServices:
"""AdGuard Control Hub services.""" """Handle services for AdGuard Control Hub."""
def __init__(self, hass: HomeAssistant) -> None: def __init__(self, hass: HomeAssistant) -> None:
"""Initialize services.""" """Initialize the services."""
self.hass = hass self.hass = hass
def register_services(self) -> None: def register_services(self) -> None:
"""Register services.""" """Register all services."""
# FIXED: All service constants are now properly defined _LOGGER.debug("Registering AdGuard Control Hub services")
self.hass.services.register(
DOMAIN,
SERVICE_BLOCK_SERVICES,
self.block_services,
)
self.hass.services.register( services = [
DOMAIN, (SERVICE_BLOCK_SERVICES, self.block_services, SCHEMA_BLOCK_SERVICES),
SERVICE_UNBLOCK_SERVICES, (SERVICE_UNBLOCK_SERVICES, self.unblock_services, SCHEMA_UNBLOCK_SERVICES),
self.unblock_services, (SERVICE_EMERGENCY_UNBLOCK, self.emergency_unblock, SCHEMA_EMERGENCY_UNBLOCK),
) (SERVICE_ADD_CLIENT, self.add_client, SCHEMA_ADD_CLIENT),
(SERVICE_REMOVE_CLIENT, self.remove_client, SCHEMA_REMOVE_CLIENT),
(SERVICE_REFRESH_DATA, self.refresh_data, SCHEMA_REFRESH_DATA),
]
self.hass.services.register( for service_name, service_func, schema in services:
DOMAIN, if not self.hass.services.has_service(DOMAIN, service_name):
SERVICE_EMERGENCY_UNBLOCK, self.hass.services.register(DOMAIN, service_name, service_func, schema=schema)
self.emergency_unblock, _LOGGER.debug("Registered service: %s", service_name)
)
self.hass.services.register(
DOMAIN,
SERVICE_ADD_CLIENT,
self.add_client,
)
self.hass.services.register(
DOMAIN,
SERVICE_REMOVE_CLIENT,
self.remove_client,
)
self.hass.services.register(
DOMAIN,
SERVICE_REFRESH_DATA,
self.refresh_data,
)
_LOGGER.info("AdGuard Control Hub services registered")
def unregister_services(self) -> None: def unregister_services(self) -> None:
"""Unregister services.""" """Unregister all services."""
_LOGGER.debug("Unregistering AdGuard Control Hub services")
services = [ services = [
SERVICE_BLOCK_SERVICES, SERVICE_BLOCK_SERVICES,
SERVICE_UNBLOCK_SERVICES, SERVICE_UNBLOCK_SERVICES,
@@ -85,163 +98,179 @@ class AdGuardControlHubServices:
SERVICE_REFRESH_DATA, SERVICE_REFRESH_DATA,
] ]
for service in services: for service_name in services:
if self.hass.services.has_service(DOMAIN, service): if self.hass.services.has_service(DOMAIN, service_name):
self.hass.services.remove(DOMAIN, service) self.hass.services.remove(DOMAIN, service_name)
_LOGGER.debug("Unregistered service: %s", service_name)
_LOGGER.info("AdGuard Control Hub services unregistered") def _get_api_instances(self) -> list[AdGuardHomeAPI]:
"""Get all API instances."""
def _get_api(self): apis = []
"""Get API instance from first available entry.""" for entry_data in self.hass.data.get(DOMAIN, {}).values():
for entry_id, entry_data in self.hass.data[DOMAIN].items():
if isinstance(entry_data, dict) and "api" in entry_data: if isinstance(entry_data, dict) and "api" in entry_data:
return entry_data["api"] apis.append(entry_data["api"])
raise AdGuardConnectionError("No AdGuard Control Hub API available") return apis
def _get_coordinator(self):
"""Get coordinator instance from first available entry."""
for entry_id, entry_data in self.hass.data[DOMAIN].items():
if isinstance(entry_data, dict) and "coordinator" in entry_data:
return entry_data["coordinator"]
raise AdGuardConnectionError("No AdGuard Control Hub coordinator available")
async def block_services(self, call: ServiceCall) -> None: async def block_services(self, call: ServiceCall) -> None:
"""Block services for a client.""" """Block services for a specific client."""
client_name = call.data[ATTR_CLIENT_NAME] client_name = call.data[ATTR_CLIENT_NAME]
services_to_block = call.data[ATTR_SERVICES] services = call.data[ATTR_SERVICES]
_LOGGER.info("Blocking services %s for client %s", services, client_name)
success_count = 0
for api in self._get_api_instances():
try: try:
api = self._get_api()
client = await api.get_client_by_name(client_name) client = await api.get_client_by_name(client_name)
if client:
current_blocked = client.get("blocked_services", {})
if isinstance(current_blocked, dict):
current_services = current_blocked.get("ids", [])
else:
current_services = current_blocked or []
if not client: updated_services = list(set(current_services + services))
_LOGGER.error("Client '%s' not found", client_name) await api.update_client_blocked_services(client_name, updated_services)
return success_count += 1
_LOGGER.info("Successfully blocked services for %s", client_name)
# Get current blocked services and add new ones else:
current_blocked = set(client.get("blocked_services", [])) _LOGGER.warning("Client %s not found", client_name)
current_blocked.update(services_to_block)
await api.update_client_blocked_services(
client_name, list(current_blocked)
)
coordinator = self._get_coordinator()
await coordinator.async_request_refresh()
_LOGGER.info(
"Blocked services %s for client '%s'", services_to_block, client_name
)
except AdGuardHomeError as err: except AdGuardHomeError as err:
_LOGGER.error("Failed to block services for '%s': %s", client_name, err) _LOGGER.error("AdGuard error blocking services for %s: %s", client_name, err)
except Exception as err:
_LOGGER.exception("Unexpected error blocking services for %s: %s", client_name, err)
if success_count == 0:
_LOGGER.error("Failed to block services for %s on any instance", client_name)
async def unblock_services(self, call: ServiceCall) -> None: async def unblock_services(self, call: ServiceCall) -> None:
"""Unblock services for a client.""" """Unblock services for a specific client."""
client_name = call.data[ATTR_CLIENT_NAME] client_name = call.data[ATTR_CLIENT_NAME]
services_to_unblock = call.data[ATTR_SERVICES] services = call.data[ATTR_SERVICES]
_LOGGER.info("Unblocking services %s for client %s", services, client_name)
success_count = 0
for api in self._get_api_instances():
try: try:
api = self._get_api()
client = await api.get_client_by_name(client_name) client = await api.get_client_by_name(client_name)
if client:
current_blocked = client.get("blocked_services", {})
if isinstance(current_blocked, dict):
current_services = current_blocked.get("ids", [])
else:
current_services = current_blocked or []
if not client: updated_services = [s for s in current_services if s not in services]
_LOGGER.error("Client '%s' not found", client_name) await api.update_client_blocked_services(client_name, updated_services)
return success_count += 1
_LOGGER.info("Successfully unblocked services for %s", client_name)
# Get current blocked services and remove specified ones else:
current_blocked = set(client.get("blocked_services", [])) _LOGGER.warning("Client %s not found", client_name)
current_blocked.difference_update(services_to_unblock)
await api.update_client_blocked_services(
client_name, list(current_blocked)
)
coordinator = self._get_coordinator()
await coordinator.async_request_refresh()
_LOGGER.info(
"Unblocked services %s for client '%s'", services_to_unblock, client_name
)
except AdGuardHomeError as err: except AdGuardHomeError as err:
_LOGGER.error("Failed to unblock services for '%s': %s", client_name, err) _LOGGER.error("AdGuard error unblocking services for %s: %s", client_name, err)
except Exception as err:
_LOGGER.exception("Unexpected error unblocking services for %s: %s", client_name, err)
if success_count == 0:
_LOGGER.error("Failed to unblock services for %s on any instance", client_name)
async def emergency_unblock(self, call: ServiceCall) -> None: async def emergency_unblock(self, call: ServiceCall) -> None:
"""Emergency unblock - disable protection temporarily.""" """Emergency unblock - temporarily disable protection."""
duration = call.data.get(ATTR_DURATION, 300) duration = call.data[ATTR_DURATION]
clients = call.data.get(ATTR_CLIENTS, ["all"]) clients = call.data[ATTR_CLIENTS]
_LOGGER.warning("Emergency unblock activated for %s seconds", duration)
for api in self._get_api_instances():
try: try:
api = self._get_api()
if "all" in clients: if "all" in clients:
# Global protection disable
await api.set_protection(False) await api.set_protection(False)
_LOGGER.warning( _LOGGER.warning("Protection disabled for %s:%s", api.host, api.port)
"Emergency unblock activated globally for %d seconds", duration
)
coordinator = self._get_coordinator() # Re-enable after duration
await coordinator.async_request_refresh() async def delayed_enable(api_instance: AdGuardHomeAPI):
# Schedule re-enabling protection
async def restore_protection():
await asyncio.sleep(duration) await asyncio.sleep(duration)
try: try:
if "all" in clients: await api_instance.set_protection(True)
await api.set_protection(True) _LOGGER.info("Emergency unblock expired - protection re-enabled for %s:%s",
api_instance.host, api_instance.port)
await coordinator.async_request_refresh()
_LOGGER.info("Emergency unblock period ended, protection restored")
except Exception as err: except Exception as err:
_LOGGER.error("Failed to restore protection after emergency unblock: %s", err) _LOGGER.error("Failed to re-enable protection for %s:%s: %s",
api_instance.host, api_instance.port, err)
# Schedule restoration asyncio.create_task(delayed_enable(api))
self.hass.async_create_task(restore_protection()) else:
# Individual client emergency unblock
for client_name in clients:
if client_name == "all":
continue
try:
client = await api.get_client_by_name(client_name)
if client:
update_data = {
"name": client_name,
"data": {**client, "filtering_enabled": False}
}
await api.update_client(update_data)
_LOGGER.info("Emergency unblock applied to client %s", client_name)
except Exception as err:
_LOGGER.error("Failed to emergency unblock client %s: %s", client_name, err)
except AdGuardHomeError as err: except AdGuardHomeError as err:
_LOGGER.error("Failed to activate emergency unblock: %s", err) _LOGGER.error("AdGuard error during emergency unblock: %s", err)
except Exception as err:
_LOGGER.exception("Unexpected error during emergency unblock: %s", err)
async def add_client(self, call: ServiceCall) -> None: async def add_client(self, call: ServiceCall) -> None:
"""Add a new client.""" """Add a new client."""
client_data = dict(call.data) client_data = dict(call.data)
_LOGGER.info("Adding new client: %s", client_data.get("name"))
success_count = 0
for api in self._get_api_instances():
try: try:
api = self._get_api()
await api.add_client(client_data) await api.add_client(client_data)
success_count += 1
coordinator = self._get_coordinator() _LOGGER.info("Successfully added client: %s", client_data.get("name"))
await coordinator.async_request_refresh()
_LOGGER.info("Added new client: %s", client_data["name"])
except AdGuardHomeError as err: except AdGuardHomeError as err:
_LOGGER.error("Failed to add client '%s': %s", client_data["name"], err) _LOGGER.error("AdGuard error adding client: %s", err)
except Exception as err:
_LOGGER.exception("Unexpected error adding client: %s", err)
if success_count == 0:
_LOGGER.error("Failed to add client %s on any instance", client_data.get("name"))
async def remove_client(self, call: ServiceCall) -> None: async def remove_client(self, call: ServiceCall) -> None:
"""Remove a client.""" """Remove a client."""
client_name = call.data["name"] client_name = call.data.get("name")
_LOGGER.info("Removing client: %s", client_name)
success_count = 0
for api in self._get_api_instances():
try: try:
api = self._get_api()
await api.delete_client(client_name) await api.delete_client(client_name)
success_count += 1
coordinator = self._get_coordinator() _LOGGER.info("Successfully removed client: %s", client_name)
await coordinator.async_request_refresh()
_LOGGER.info("Removed client: %s", client_name)
except AdGuardHomeError as err: except AdGuardHomeError as err:
_LOGGER.error("Failed to remove client '%s': %s", client_name, err) _LOGGER.error("AdGuard error removing client: %s", err)
except Exception as err:
_LOGGER.exception("Unexpected error removing client: %s", err)
if success_count == 0:
_LOGGER.error("Failed to remove client %s on any instance", client_name)
async def refresh_data(self, call: ServiceCall) -> None: async def refresh_data(self, call: ServiceCall) -> None:
"""Refresh data from AdGuard Home.""" """Refresh data for all coordinators."""
_LOGGER.info("Manually refreshing AdGuard Control Hub data")
for entry_data in self.hass.data.get(DOMAIN, {}).values():
if isinstance(entry_data, dict) and "coordinator" in entry_data:
coordinator = entry_data["coordinator"]
try: try:
coordinator = self._get_coordinator()
await coordinator.async_request_refresh() await coordinator.async_request_refresh()
_LOGGER.debug("Refreshed coordinator data")
_LOGGER.info("Data refresh requested")
except Exception as err: except Exception as err:
_LOGGER.error("Failed to refresh data: %s", err) _LOGGER.error("Failed to refresh coordinator: %s", err)

262
custom_components/adguard_hub/switch.py
View File

@@ -1,16 +1,17 @@
"""AdGuard Control Hub switch platform.""" """Switch platform for AdGuard Control Hub integration."""
import logging import logging
from typing import Any, Dict, List, Optional from typing import Any, Optional
from homeassistant.components.switch import SwitchEntity from homeassistant.components.switch import SwitchEntity, SwitchDeviceClass
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import EntityCategory
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import CoordinatorEntity from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.helpers.entity import DeviceInfo
from .api import AdGuardHomeAPI, AdGuardConnectionError from . import AdGuardControlHubCoordinator
from .const import DOMAIN, MANUFACTURER from .api import AdGuardHomeAPI, AdGuardHomeError
from .const import DOMAIN, ICON_PROTECTION, ICON_PROTECTION_OFF, ICON_CLIENT, MANUFACTURER
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@@ -24,122 +25,189 @@ async def async_setup_entry(
coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"] coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
api = hass.data[DOMAIN][config_entry.entry_id]["api"] api = hass.data[DOMAIN][config_entry.entry_id]["api"]
entities: List[SwitchEntity] = [] entities = [AdGuardProtectionSwitch(coordinator, api)]
# Add main protection switch # Add client switches if clients exist
entities.append(AdGuardProtectionSwitch(coordinator, api)) for client_name in coordinator.clients.keys():
# Add client switches
for client_name in coordinator.clients:
entities.append(AdGuardClientSwitch(coordinator, api, client_name)) entities.append(AdGuardClientSwitch(coordinator, api, client_name))
async_add_entities(entities) async_add_entities(entities, update_before_add=True)
class AdGuardProtectionSwitch(CoordinatorEntity, SwitchEntity): class AdGuardBaseSwitch(CoordinatorEntity, SwitchEntity):
"""AdGuard Home protection switch.""" """Base class for AdGuard switches."""
def __init__(self, coordinator, api: AdGuardHomeAPI) -> None: def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the switch.""" """Initialize the switch."""
super().__init__(coordinator) super().__init__(coordinator)
self.api = api self.api = api
self._attr_device_info = {
"identifiers": {(DOMAIN, f"{api.host}:{api.port}")},
"name": f"AdGuard Control Hub ({api.host})",
"manufacturer": MANUFACTURER,
"model": "AdGuard Home",
"configuration_url": f"{'https' if api.ssl else 'http'}://{api.host}:{api.port}",
}
@property
def available(self) -> bool:
"""Return if switch is available."""
return self.coordinator.last_update_success
class AdGuardProtectionSwitch(AdGuardBaseSwitch):
"""Switch to control global AdGuard protection."""
def __init__(self, coordinator: AdGuardControlHubCoordinator, api: AdGuardHomeAPI) -> None:
"""Initialize the switch."""
super().__init__(coordinator, api)
self._attr_unique_id = f"{api.host}_{api.port}_protection"
self._attr_name = "AdGuard Protection" self._attr_name = "AdGuard Protection"
self._attr_unique_id = f"{DOMAIN}_protection" self._attr_device_class = SwitchDeviceClass.SWITCH
self._attr_entity_category = EntityCategory.CONFIG
@property @property
def device_info(self) -> DeviceInfo: def is_on(self) -> Optional[bool]:
"""Return device info."""
return DeviceInfo(
identifiers={(DOMAIN, "adguard_home")},
name="AdGuard Home",
manufacturer=MANUFACTURER, # FIXED: Now uses imported MANUFACTURER
model="AdGuard Home",
configuration_url=self.api.base_url,
)
@property
def is_on(self) -> bool:
"""Return true if protection is enabled.""" """Return true if protection is enabled."""
return self.coordinator.protection_status.get("protection_enabled", False) return self.coordinator.protection_status.get("protection_enabled", False)
@property @property
def icon(self) -> str: def icon(self) -> str:
"""Return the icon.""" """Return the icon for the switch."""
return "mdi:shield-check" if self.is_on else "mdi:shield-off" return ICON_PROTECTION if self.is_on else ICON_PROTECTION_OFF
async def async_turn_on(self, **kwargs: Any) -> None:
"""Turn on protection."""
try:
await self.api.set_protection(True)
await self.coordinator.async_request_refresh()
except AdGuardConnectionError as err:
_LOGGER.error("Failed to turn on protection: %s", err)
async def async_turn_off(self, **kwargs: Any) -> None:
"""Turn off protection."""
try:
await self.api.set_protection(False)
await self.coordinator.async_request_refresh()
except AdGuardConnectionError as err:
_LOGGER.error("Failed to turn off protection: %s", err)
class AdGuardClientSwitch(CoordinatorEntity, SwitchEntity):
"""AdGuard Home client switch."""
def __init__(self, coordinator, api: AdGuardHomeAPI, client_name: str) -> None:
"""Initialize the client switch."""
super().__init__(coordinator)
self.api = api
self._client_name = client_name
self._attr_name = f"AdGuard {client_name}"
self._attr_unique_id = f"{DOMAIN}_{client_name.lower().replace(' ', '_')}"
@property
def device_info(self) -> DeviceInfo:
"""Return device info."""
return DeviceInfo(
identifiers={(DOMAIN, f"client_{self._client_name}")},
name=f"AdGuard Client: {self._client_name}",
manufacturer=MANUFACTURER,
model="AdGuard Client",
via_device=(DOMAIN, "adguard_home"),
)
@property
def is_on(self) -> bool:
"""Return true if client filtering is enabled."""
client = self.coordinator.clients.get(self._client_name, {})
return not client.get("filtering_enabled", True) is False
@property
def icon(self) -> str:
"""Return the icon."""
return "mdi:devices" if self.is_on else "mdi:devices-off"
@property @property
def available(self) -> bool: def available(self) -> bool:
"""Return if entity is available.""" """Return if switch is available."""
return self._client_name in self.coordinator.clients return self.coordinator.last_update_success and bool(self.coordinator.protection_status)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
status = self.coordinator.protection_status
return {
"dns_port": status.get("dns_port", "N/A"),
"version": status.get("version", "N/A"),
"running": status.get("running", False),
"dns_addresses": status.get("dns_addresses", []),
}
async def async_turn_on(self, **kwargs: Any) -> None: async def async_turn_on(self, **kwargs: Any) -> None:
"""Enable filtering for client.""" """Turn on AdGuard protection."""
try: try:
client = await self.api.get_client_by_name(self._client_name) await self.api.set_protection(True)
if client:
client["filtering_enabled"] = True
await self.api._request("POST", "/control/clients/update", json=client)
await self.coordinator.async_request_refresh() await self.coordinator.async_request_refresh()
except AdGuardConnectionError as err: _LOGGER.info("AdGuard protection enabled")
_LOGGER.error("Failed to enable filtering for %s: %s", self._client_name, err) except AdGuardHomeError as err:
_LOGGER.error("Failed to enable AdGuard protection: %s", err)
raise
except Exception as err:
_LOGGER.exception("Unexpected error enabling AdGuard protection")
raise
async def async_turn_off(self, **kwargs: Any) -> None: async def async_turn_off(self, **kwargs: Any) -> None:
"""Disable filtering for client.""" """Turn off AdGuard protection."""
try: try:
client = await self.api.get_client_by_name(self._client_name) await self.api.set_protection(False)
if client:
client["filtering_enabled"] = False
await self.api._request("POST", "/control/clients/update", json=client)
await self.coordinator.async_request_refresh() await self.coordinator.async_request_refresh()
except AdGuardConnectionError as err: _LOGGER.warning("AdGuard protection disabled")
_LOGGER.error("Failed to disable filtering for %s: %s", self._client_name, err) except AdGuardHomeError as err:
_LOGGER.error("Failed to disable AdGuard protection: %s", err)
raise
except Exception as err:
_LOGGER.exception("Unexpected error disabling AdGuard protection")
raise
class AdGuardClientSwitch(AdGuardBaseSwitch):
"""Switch to control client-specific protection."""
def __init__(
self,
coordinator: AdGuardControlHubCoordinator,
api: AdGuardHomeAPI,
client_name: str,
) -> None:
"""Initialize the switch."""
super().__init__(coordinator, api)
self.client_name = client_name
self._attr_unique_id = f"{api.host}_{api.port}_client_{client_name}"
self._attr_name = f"AdGuard {client_name}"
self._attr_icon = ICON_CLIENT
self._attr_device_class = SwitchDeviceClass.SWITCH
self._attr_entity_category = EntityCategory.CONFIG
@property
def is_on(self) -> Optional[bool]:
"""Return true if client protection is enabled."""
client = self.coordinator.clients.get(self.client_name, {})
return client.get("filtering_enabled", True)
@property
def available(self) -> bool:
"""Return if switch is available."""
return (
self.coordinator.last_update_success
and self.client_name in self.coordinator.clients
)
@property
def extra_state_attributes(self) -> dict[str, Any]:
"""Return additional state attributes."""
client = self.coordinator.clients.get(self.client_name, {})
blocked_services = client.get("blocked_services", {})
if isinstance(blocked_services, dict):
blocked_list = blocked_services.get("ids", [])
else:
blocked_list = blocked_services or []
return {
"client_ids": client.get("ids", []),
"safebrowsing_enabled": client.get("safebrowsing_enabled", False),
"parental_enabled": client.get("parental_enabled", False),
"safesearch_enabled": client.get("safesearch_enabled", False),
"blocked_services_count": len(blocked_list),
"blocked_services": blocked_list,
}
async def async_turn_on(self, **kwargs: Any) -> None:
"""Enable protection for this client."""
try:
client = await self.api.get_client_by_name(self.client_name)
if client:
update_data = {
"name": self.client_name,
"data": {**client, "filtering_enabled": True}
}
await self.api.update_client(update_data)
await self.coordinator.async_request_refresh()
_LOGGER.info("Enabled protection for client: %s", self.client_name)
else:
_LOGGER.error("Client not found: %s", self.client_name)
except AdGuardHomeError as err:
_LOGGER.error("Failed to enable protection for %s: %s", self.client_name, err)
raise
except Exception as err:
_LOGGER.exception("Unexpected error enabling protection for %s", self.client_name)
raise
async def async_turn_off(self, **kwargs: Any) -> None:
"""Disable protection for this client."""
try:
client = await self.api.get_client_by_name(self.client_name)
if client:
update_data = {
"name": self.client_name,
"data": {**client, "filtering_enabled": False}
}
await self.api.update_client(update_data)
await self.coordinator.async_request_refresh()
_LOGGER.info("Disabled protection for client: %s", self.client_name)
else:
_LOGGER.error("Client not found: %s", self.client_name)
except AdGuardHomeError as err:
_LOGGER.error("Failed to disable protection for %s: %s", self.client_name, err)
raise
except Exception as err:
_LOGGER.exception("Unexpected error disabling protection for %s", self.client_name)
raise

2
pyproject.toml
View File

@@ -16,7 +16,7 @@ addopts = [
"--cov=custom_components.adguard_hub", "--cov=custom_components.adguard_hub",
"--cov-report=term-missing", "--cov-report=term-missing",
"--cov-report=html", "--cov-report=html",
"--cov-fail-under=70", "--cov-fail-under=60",
"--asyncio-mode=auto", "--asyncio-mode=auto",
"-v" "-v"
] ]

185
tests/conftest.py
View File

@@ -1,36 +1,28 @@
"""Test configuration for AdGuard Control Hub.""" """Test configuration and fixtures."""
import pytest import pytest
from unittest.mock import AsyncMock, MagicMock from unittest.mock import AsyncMock, MagicMock
from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant
from homeassistant.const import CONF_HOST, CONF_PORT, CONF_USERNAME, CONF_PASSWORD from homeassistant.config_entries import ConfigEntry, SOURCE_USER
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT, CONF_USERNAME
from custom_components.adguard_hub.api import AdGuardHomeAPI
from custom_components.adguard_hub.const import DOMAIN, CONF_SSL, CONF_VERIFY_SSL from custom_components.adguard_hub.const import DOMAIN, CONF_SSL, CONF_VERIFY_SSL
@pytest.fixture @pytest.fixture(autouse=True)
def mock_hass(): def auto_enable_custom_integrations(enable_custom_integrations):
"""Mock Home Assistant.""" """Enable custom integrations for all tests."""
hass = MagicMock() yield
hass.data = {}
hass.config_entries = MagicMock()
hass.config_entries.async_forward_entry_setups = AsyncMock(return_value=True)
hass.config_entries.async_unload_platforms = AsyncMock(return_value=True)
hass.services = MagicMock()
hass.services.register = MagicMock()
hass.services.remove = MagicMock()
hass.services.has_service = MagicMock(return_value=True)
hass.async_create_task = MagicMock()
return hass
@pytest.fixture @pytest.fixture
def mock_config_entry(): def mock_config_entry():
"""Mock config entry.""" """Mock config entry for testing."""
return ConfigEntry( return ConfigEntry(
version=1, version=1,
minor_version=1, minor_version=1,
domain=DOMAIN, domain=DOMAIN,
title="AdGuard Control Hub", title="Test AdGuard Control Hub",
data={ data={
CONF_HOST: "192.168.1.100", CONF_HOST: "192.168.1.100",
CONF_PORT: 3000, CONF_PORT: 3000,
@@ -40,109 +32,186 @@ def mock_config_entry():
CONF_VERIFY_SSL: True, CONF_VERIFY_SSL: True,
}, },
options={}, options={},
source="user", source=SOURCE_USER,
entry_id="test_entry_id",
unique_id="192.168.1.100:3000", unique_id="192.168.1.100:3000",
discovery_keys={}, # FIXED: Added missing parameter discovery_keys=set(), # Added required parameter
subentries_data={}, # FIXED: Added missing parameter subentries_data={}, # Added required parameter
) )
@pytest.fixture @pytest.fixture
def mock_api(): def mock_api():
"""Mock AdGuard Home API.""" """Mock AdGuard Home API."""
api = MagicMock() api = MagicMock(spec=AdGuardHomeAPI)
api.host = "192.168.1.100" api.host = "192.168.1.100"
api.port = 3000 api.port = 3000
api.base_url = "http://192.168.1.100:3000"
api.username = "admin"
api.password = "password"
api.ssl = False api.ssl = False
api.verify_ssl = True api.verify_ssl = True
# Mock API methods # Mock successful connection
api.test_connection = AsyncMock(return_value=True) api.test_connection = AsyncMock(return_value=True)
# Mock status response
api.get_status = AsyncMock(return_value={ api.get_status = AsyncMock(return_value={
"protection_enabled": True, "protection_enabled": True,
"version": "v0.108.0", "version": "v0.107.0",
"dns_port": 53,
"running": True, "running": True,
"dns_addresses": ["192.168.1.100:53"],
"bootstrap_dns": ["1.1.1.1", "8.8.8.8"],
"upstream_dns": ["1.1.1.1", "8.8.8.8", "1.0.0.1", "8.8.4.4"],
"safebrowsing_enabled": True, "safebrowsing_enabled": True,
"parental_enabled": False, "parental_enabled": False,
"safesearch_enabled": True, "safesearch_enabled": False,
"num_filtering_rules": 75000, "dhcp_available": False,
"dns_addresses": ["8.8.8.8", "8.8.4.4"],
}) })
# Mock clients response
api.get_clients = AsyncMock(return_value={ api.get_clients = AsyncMock(return_value={
"clients": [ "clients": [
{ {
"name": "test_client", "name": "test_client",
"ids": ["192.168.1.200"], "ids": ["192.168.1.50"],
"filtering_enabled": True, "filtering_enabled": True,
"safebrowsing_enabled": True, "safebrowsing_enabled": False,
"parental_enabled": False, "parental_enabled": False,
"blocked_services": ["youtube"], "safesearch_enabled": False,
"use_global_settings": True,
"use_global_blocked_services": True,
"blocked_services": {"ids": ["youtube", "gaming"]},
},
{
"name": "test_client_2",
"ids": ["192.168.1.51"],
"filtering_enabled": False,
"safebrowsing_enabled": True,
"parental_enabled": True,
"safesearch_enabled": False,
"use_global_settings": False,
"blocked_services": {"ids": ["netflix"]},
} }
] ]
}) })
# Mock statistics response
api.get_statistics = AsyncMock(return_value={ api.get_statistics = AsyncMock(return_value={
"num_dns_queries": 10000, "num_dns_queries": 10000,
"num_blocked_filtering": 2500, "num_blocked_filtering": 1500,
"avg_processing_time": 1.5, "num_dns_queries_today": 5000,
"num_blocked_filtering_today": 750,
"num_replaced_safebrowsing": 50,
"num_replaced_parental": 25,
"num_replaced_safesearch": 10,
"avg_processing_time": 2.5,
"filtering_rules_count": 75000,
}) })
api.set_protection = AsyncMock() # Mock client operations
api.get_client_by_name = AsyncMock(return_value={ api.get_client_by_name = AsyncMock(return_value={
"name": "test_client", "name": "test_client",
"ids": ["192.168.1.200"], "ids": ["192.168.1.50"],
"filtering_enabled": True, "filtering_enabled": True,
"blocked_services": ["youtube"], "blocked_services": {"ids": ["youtube"]},
}) })
api.update_client_blocked_services = AsyncMock()
api.add_client = AsyncMock() api.add_client = AsyncMock(return_value={"success": True})
api.delete_client = AsyncMock() api.update_client = AsyncMock(return_value={"success": True})
api._request = AsyncMock() api.delete_client = AsyncMock(return_value={"success": True})
api.update_client_blocked_services = AsyncMock(return_value={"success": True})
api.set_protection = AsyncMock(return_value={"success": True})
api.close = AsyncMock(return_value=None)
return api return api
@pytest.fixture @pytest.fixture
def mock_coordinator(): def mock_coordinator(mock_api):
"""Mock coordinator.""" """Mock coordinator with test data."""
coordinator = MagicMock() from custom_components.adguard_hub import AdGuardControlHubCoordinator
coordinator.async_request_refresh = AsyncMock()
coordinator = MagicMock(spec=AdGuardControlHubCoordinator)
coordinator.last_update_success = True
coordinator.api = mock_api
# Mock clients data
coordinator.clients = { coordinator.clients = {
"test_client": { "test_client": {
"name": "test_client", "name": "test_client",
"ids": ["192.168.1.200"], "ids": ["192.168.1.50"],
"filtering_enabled": True, "filtering_enabled": True,
"blocked_services": ["youtube"], "blocked_services": {"ids": ["youtube"]},
},
"test_client_2": {
"name": "test_client_2",
"ids": ["192.168.1.51"],
"filtering_enabled": False,
"blocked_services": {"ids": ["netflix"]},
} }
} }
# Mock statistics data
coordinator.statistics = { coordinator.statistics = {
"num_dns_queries": 10000, "num_dns_queries": 10000,
"num_blocked_filtering": 2500, "num_blocked_filtering": 1500,
"avg_processing_time": 1.5, "avg_processing_time": 2.5,
"filtering_rules_count": 75000,
} }
# Mock protection status
coordinator.protection_status = { coordinator.protection_status = {
"protection_enabled": True, "protection_enabled": True,
"version": "v0.108.0", "version": "v0.107.0",
"dns_port": 53,
"running": True, "running": True,
"safebrowsing_enabled": True, "safebrowsing_enabled": True,
"parental_enabled": False, "parental_enabled": False,
"safesearch_enabled": False,
} }
coordinator.data = {
"clients": coordinator.clients,
"statistics": coordinator.statistics,
"status": coordinator.protection_status,
}
coordinator.async_request_refresh = AsyncMock()
return coordinator return coordinator
@pytest.fixture
def mock_hass():
"""Mock Home Assistant instance."""
hass = MagicMock(spec=HomeAssistant)
hass.data = {}
hass.services = MagicMock()
hass.services.has_service = MagicMock(return_value=False)
hass.services.register = MagicMock()
hass.services.remove = MagicMock()
hass.config_entries = MagicMock()
hass.config_entries.async_forward_entry_setups = AsyncMock(return_value=True)
hass.config_entries.async_unload_platforms = AsyncMock(return_value=True)
return hass
@pytest.fixture @pytest.fixture
def mock_aiohttp_session(): def mock_aiohttp_session():
"""Mock aiohttp session.""" """Mock aiohttp session."""
session = AsyncMock() session = MagicMock()
response = AsyncMock() response = MagicMock()
response.status = 200 response.raise_for_status = MagicMock()
response.json = AsyncMock(return_value={"status": "ok"}) response.json = AsyncMock(return_value={"status": "ok"})
session.request = AsyncMock(return_value=response) response.text = AsyncMock(return_value="OK")
session.__aenter__ = AsyncMock(return_value=response) response.status = 200
session.__aexit__ = AsyncMock() response.content_length = 100
# Mock async context manager
context_manager = MagicMock()
context_manager.__aenter__ = AsyncMock(return_value=response)
context_manager.__aexit__ = AsyncMock(return_value=None)
session.request = MagicMock(return_value=context_manager)
session.close = AsyncMock()
return session return session

280
tests/test_api.py
View File

@@ -1,29 +1,20 @@
"""Test AdGuard Home API client.""" """Test API functionality."""
import pytest import pytest
from unittest.mock import AsyncMock, patch from unittest.mock import AsyncMock, MagicMock, patch
import aiohttp from aiohttp import ClientError, ClientTimeout
from custom_components.adguard_hub.api import ( from custom_components.adguard_hub.api import (
AdGuardHomeAPI, AdGuardHomeAPI,
AdGuardHomeError,
AdGuardConnectionError, AdGuardConnectionError,
AdGuardAuthError, AdGuardAuthError,
AdGuardNotFoundError,
AdGuardTimeoutError, AdGuardTimeoutError,
) )
class TestAdGuardHomeAPI: class TestAdGuardHomeAPI:
"""Test AdGuard Home API client.""" """Test the AdGuard Home API wrapper."""
@pytest.fixture
def api(self, mock_aiohttp_session):
"""Create API instance."""
return AdGuardHomeAPI(
host="192.168.1.100",
port=3000,
username="admin",
password="password",
session=mock_aiohttp_session,
)
def test_api_initialization(self): def test_api_initialization(self):
"""Test API initialization.""" """Test API initialization."""
@@ -32,49 +23,266 @@ class TestAdGuardHomeAPI:
port=3000, port=3000,
username="admin", username="admin",
password="password", password="password",
ssl=True,
) )
assert api.host == "192.168.1.100" assert api.host == "192.168.1.100"
assert api.port == 3000 assert api.port == 3000
assert api.username == "admin" assert api.username == "admin"
assert api.password == "password" assert api.password == "password"
assert api.ssl is True
assert api.base_url == "https://192.168.1.100:3000"
def test_api_initialization_defaults(self):
"""Test API initialization with defaults."""
api = AdGuardHomeAPI(host="192.168.1.100")
assert api.host == "192.168.1.100"
assert api.port == 3000
assert api.username is None
assert api.password is None
assert api.ssl is False
assert api.base_url == "http://192.168.1.100:3000" assert api.base_url == "http://192.168.1.100:3000"
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_connection_success(self, api): async def test_api_context_manager(self):
"""Test successful connection.""" """Test API as async context manager."""
result = await api.test_connection() async with AdGuardHomeAPI(host="192.168.1.100", port=3000) as api:
assert result is True assert api is not None
assert api.host == "192.168.1.100"
assert api.port == 3000
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_get_status(self, api, mock_aiohttp_session): async def test_test_connection_success(self, mock_aiohttp_session):
"""Test getting status.""" """Test successful connection test."""
expected_response = { mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value={"protection_enabled": True}
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
result = await api.test_connection()
assert result is True
mock_aiohttp_session.request.assert_called()
@pytest.mark.asyncio
async def test_test_connection_failure(self, mock_aiohttp_session):
"""Test failed connection test."""
mock_aiohttp_session.request.side_effect = ClientError("Connection failed")
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
result = await api.test_connection()
assert result is False
@pytest.mark.asyncio
async def test_get_status_success(self, mock_aiohttp_session):
"""Test successful status retrieval."""
expected_status = {
"protection_enabled": True, "protection_enabled": True,
"version": "v0.108.0", "version": "v0.107.0",
"running": True, "running": True,
} }
mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock( mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value=expected_response return_value=expected_status
) )
result = await api.get_status() api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
assert result == expected_response status = await api.get_status()
assert status == expected_status
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_auth_error(self, api, mock_aiohttp_session): async def test_get_clients_success(self, mock_aiohttp_session):
"""Test authentication error.""" """Test successful clients retrieval."""
mock_aiohttp_session.request.return_value.__aenter__.return_value.status = 401 expected_clients = {
"clients": [
{"name": "client1", "ids": ["192.168.1.50"]},
{"name": "client2", "ids": ["192.168.1.51"]},
]
}
with pytest.raises(AdGuardAuthError): mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value=expected_clients
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
clients = await api.get_clients()
assert clients == expected_clients
@pytest.mark.asyncio
async def test_get_statistics_success(self, mock_aiohttp_session):
"""Test successful statistics retrieval."""
expected_stats = {
"num_dns_queries": 10000,
"num_blocked_filtering": 1500,
}
mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value=expected_stats
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
stats = await api.get_statistics()
assert stats == expected_stats
@pytest.mark.asyncio
async def test_set_protection_enable(self, mock_aiohttp_session):
"""Test enabling protection."""
mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value={"success": True}
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
result = await api.set_protection(True)
assert result == {"success": True}
@pytest.mark.asyncio
async def test_add_client_success(self, mock_aiohttp_session):
"""Test successful client addition."""
client_data = {
"name": "test_client",
"ids": ["192.168.1.100"],
}
mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value={"success": True}
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
result = await api.add_client(client_data)
assert result == {"success": True}
@pytest.mark.asyncio
async def test_add_client_missing_name(self, mock_aiohttp_session):
"""Test client addition with missing name."""
client_data = {"ids": ["192.168.1.100"]}
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
with pytest.raises(ValueError, match="Client name is required"):
await api.add_client(client_data)
@pytest.mark.asyncio
async def test_add_client_missing_ids(self, mock_aiohttp_session):
"""Test client addition with missing IDs."""
client_data = {"name": "test_client"}
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
with pytest.raises(ValueError, match="Client IDs are required"):
await api.add_client(client_data)
@pytest.mark.asyncio
async def test_get_client_by_name_found(self, mock_aiohttp_session):
"""Test finding client by name."""
clients_data = {
"clients": [
{"name": "test_client", "ids": ["192.168.1.50"]},
{"name": "other_client", "ids": ["192.168.1.51"]},
]
}
mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value=clients_data
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
client = await api.get_client_by_name("test_client")
assert client == {"name": "test_client", "ids": ["192.168.1.50"]}
@pytest.mark.asyncio
async def test_get_client_by_name_not_found(self, mock_aiohttp_session):
"""Test client not found by name."""
clients_data = {"clients": []}
mock_aiohttp_session.request.return_value.__aenter__.return_value.json = AsyncMock(
return_value=clients_data
)
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
client = await api.get_client_by_name("nonexistent_client")
assert client is None
@pytest.mark.asyncio
async def test_update_client_blocked_services_client_not_found(self, mock_aiohttp_session):
"""Test blocked services update with client not found."""
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
api.get_client_by_name = AsyncMock(return_value=None)
with pytest.raises(AdGuardNotFoundError, match="Client 'nonexistent' not found"):
await api.update_client_blocked_services("nonexistent", ["youtube"])
@pytest.mark.asyncio
async def test_auth_error_handling(self, mock_aiohttp_session):
"""Test 401 authentication error handling."""
mock_response = mock_aiohttp_session.request.return_value.__aenter__.return_value
mock_response.status = 401
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
with pytest.raises(AdGuardAuthError, match="Authentication failed"):
await api.get_status() await api.get_status()
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_connection_error(self, api, mock_aiohttp_session): async def test_not_found_error_handling(self, mock_aiohttp_session):
"""Test connection error.""" """Test 404 not found error handling."""
mock_aiohttp_session.request.side_effect = aiohttp.ClientConnectorError( mock_response = mock_aiohttp_session.request.return_value.__aenter__.return_value
None, OSError("Connection failed") mock_response.status = 404
)
with pytest.raises(AdGuardConnectionError): api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
with pytest.raises(AdGuardNotFoundError):
await api.get_status() await api.get_status()
@pytest.mark.asyncio
async def test_server_error_handling(self, mock_aiohttp_session):
"""Test 500 server error handling."""
mock_response = mock_aiohttp_session.request.return_value.__aenter__.return_value
mock_response.status = 500
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
with pytest.raises(AdGuardConnectionError, match="Server error 500"):
await api.get_status()
@pytest.mark.asyncio
async def test_client_error_handling(self, mock_aiohttp_session):
"""Test client error handling."""
mock_aiohttp_session.request.side_effect = ClientError("Client error")
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
with pytest.raises(AdGuardConnectionError, match="Client error"):
await api.get_status()
@pytest.mark.asyncio
async def test_empty_response_handling(self, mock_aiohttp_session):
"""Test empty response handling."""
mock_response = mock_aiohttp_session.request.return_value.__aenter__.return_value
mock_response.status = 204
mock_response.content_length = 0
api = AdGuardHomeAPI(host="192.168.1.100", session=mock_aiohttp_session)
result = await api._request("POST", "/control/protection", {"enabled": True})
assert result == {}
@pytest.mark.asyncio
async def test_close_session(self):
"""Test closing API session."""
api = AdGuardHomeAPI(host="192.168.1.100")
# Create session
async with api:
assert api._session is not None
# Close session
await api.close()

331
tests/test_integration.py
View File

@@ -46,10 +46,46 @@ class TestIntegrationSetup:
with pytest.raises(ConfigEntryNotReady, match="Unable to connect to AdGuard Home"): with pytest.raises(ConfigEntryNotReady, match="Unable to connect to AdGuard Home"):
await async_setup_entry(mock_hass, mock_config_entry) await async_setup_entry(mock_hass, mock_config_entry)
@pytest.mark.asyncio
async def test_setup_entry_api_error(self, mock_hass, mock_config_entry):
"""Test setup failure due to API error."""
mock_api = MagicMock()
mock_api.test_connection = AsyncMock(side_effect=AdGuardAuthError("Auth failed"))
with patch("custom_components.adguard_hub.AdGuardHomeAPI", return_value=mock_api), patch("custom_components.adguard_hub.async_get_clientsession"):
with pytest.raises(ConfigEntryNotReady, match="Unable to connect"):
await async_setup_entry(mock_hass, mock_config_entry)
@pytest.mark.asyncio
async def test_setup_entry_coordinator_failure(self, mock_hass, mock_config_entry, mock_api):
"""Test setup failure due to coordinator refresh error."""
with patch("custom_components.adguard_hub.AdGuardHomeAPI", return_value=mock_api), patch("custom_components.adguard_hub.async_get_clientsession"), patch.object(AdGuardControlHubCoordinator, "async_config_entry_first_refresh",
side_effect=UpdateFailed("Refresh failed")):
with pytest.raises(ConfigEntryNotReady, match="Failed to fetch initial data"):
await async_setup_entry(mock_hass, mock_config_entry)
@pytest.mark.asyncio
async def test_setup_entry_platform_failure(self, mock_hass, mock_config_entry, mock_api):
"""Test setup failure due to platform setup error."""
mock_hass.config_entries.async_forward_entry_setups = AsyncMock(
side_effect=Exception("Platform setup failed")
)
with patch("custom_components.adguard_hub.AdGuardHomeAPI", return_value=mock_api), patch("custom_components.adguard_hub.async_get_clientsession"), patch.object(AdGuardControlHubCoordinator, "async_config_entry_first_refresh",
new=AsyncMock()):
with pytest.raises(ConfigEntryNotReady, match="Failed to set up platforms"):
await async_setup_entry(mock_hass, mock_config_entry)
# Verify cleanup
assert mock_config_entry.entry_id not in mock_hass.data.get(DOMAIN, {})
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_unload_entry_success(self, mock_hass, mock_config_entry): async def test_unload_entry_success(self, mock_hass, mock_config_entry):
"""Test successful unloading of config entry.""" """Test successful unloading of config entry."""
# FIXED: Set up initial data structure properly # Set up initial data
mock_hass.data[DOMAIN] = { mock_hass.data[DOMAIN] = {
mock_config_entry.entry_id: { mock_config_entry.entry_id: {
"coordinator": MagicMock(), "coordinator": MagicMock(),
@@ -60,34 +96,40 @@ class TestIntegrationSetup:
result = await async_unload_entry(mock_hass, mock_config_entry) result = await async_unload_entry(mock_hass, mock_config_entry)
assert result is True assert result is True
# Entry should be removed after successful unload
assert mock_config_entry.entry_id not in mock_hass.data[DOMAIN] assert mock_config_entry.entry_id not in mock_hass.data[DOMAIN]
mock_hass.config_entries.async_unload_platforms.assert_called_once() mock_hass.config_entries.async_unload_platforms.assert_called_once()
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_coordinator_update_connection_error(self, mock_hass, mock_api): async def test_unload_entry_last_instance(self, mock_hass, mock_config_entry):
"""Test coordinator update with connection error.""" """Test unloading last config entry unregisters services."""
# FIXED: Make ALL API calls fail with connection errors to trigger UpdateFailed # Set up services
mock_api.get_status = AsyncMock(side_effect=AdGuardConnectionError("Connection failed")) mock_services = MagicMock()
mock_api.get_clients = AsyncMock(side_effect=AdGuardConnectionError("Connection failed")) mock_services.unregister_services = MagicMock()
mock_api.get_statistics = AsyncMock(side_effect=AdGuardConnectionError("Connection failed")) mock_hass.data[f"{DOMAIN}_services"] = mock_services
mock_hass.data[DOMAIN] = {
mock_config_entry.entry_id: {
"coordinator": MagicMock(),
"api": MagicMock(),
}
}
result = await async_unload_entry(mock_hass, mock_config_entry)
assert result is True
assert f"{DOMAIN}_services" not in mock_hass.data
assert DOMAIN not in mock_hass.data
mock_services.unregister_services.assert_called_once()
class TestCoordinator:
"""Test the data update coordinator."""
def test_coordinator_initialization(self, mock_hass, mock_api):
"""Test coordinator initialization."""
coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api) coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
# Should raise UpdateFailed when ALL API calls fail with connection errors assert coordinator.api == mock_api
with pytest.raises(UpdateFailed, match="Connection error to AdGuard Home"): assert coordinator.name == f"{DOMAIN}_coordinator"
await coordinator._async_update_data()
@pytest.mark.asyncio
async def test_coordinator_update_unexpected_error(self, mock_hass, mock_api):
"""Test coordinator update with unexpected error."""
# FIXED: Create a coordinator that will fail in asyncio.gather
coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
# Mock asyncio.gather to raise an exception directly
with patch('custom_components.adguard_hub.asyncio.gather', side_effect=Exception("Unexpected error")):
with pytest.raises(UpdateFailed, match="Error communicating with AdGuard Control Hub"):
await coordinator._async_update_data()
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_coordinator_update_success(self, mock_hass, mock_api): async def test_coordinator_update_success(self, mock_hass, mock_api):
@@ -103,6 +145,46 @@ class TestIntegrationSetup:
assert data["statistics"]["num_dns_queries"] == 10000 assert data["statistics"]["num_dns_queries"] == 10000
assert data["status"]["protection_enabled"] is True assert data["status"]["protection_enabled"] is True
@pytest.mark.asyncio
async def test_coordinator_update_partial_failure(self, mock_hass, mock_api):
"""Test coordinator update with partial API failures."""
# Make one API call fail
mock_api.get_clients = AsyncMock(side_effect=Exception("Client fetch failed"))
coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
data = await coordinator._async_update_data()
# Should still return data from successful calls
assert "clients" in data
assert "statistics" in data
assert "status" in data
assert data["statistics"]["num_dns_queries"] == 10000
@pytest.mark.asyncio
async def test_coordinator_update_connection_error(self, mock_hass, mock_api):
"""Test coordinator update with connection error."""
mock_api.get_status = AsyncMock(side_effect=AdGuardConnectionError("Connection failed"))
mock_api.get_clients = AsyncMock(side_effect=AdGuardConnectionError("Connection failed"))
mock_api.get_statistics = AsyncMock(side_effect=AdGuardConnectionError("Connection failed"))
coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
with pytest.raises(UpdateFailed, match="Connection error to AdGuard Home"):
await coordinator._async_update_data()
@pytest.mark.asyncio
async def test_coordinator_update_unexpected_error(self, mock_hass, mock_api):
"""Test coordinator update with unexpected error."""
mock_api.get_status = AsyncMock(side_effect=Exception("Unexpected error"))
mock_api.get_clients = AsyncMock(side_effect=Exception("Unexpected error"))
mock_api.get_statistics = AsyncMock(side_effect=Exception("Unexpected error"))
coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
with pytest.raises(UpdateFailed, match="Error communicating with AdGuard Control Hub"):
await coordinator._async_update_data()
def test_coordinator_properties(self, mock_hass, mock_api): def test_coordinator_properties(self, mock_hass, mock_api):
"""Test coordinator properties.""" """Test coordinator properties."""
coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api) coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
@@ -120,63 +202,182 @@ class TestIntegrationSetup:
assert coordinator.statistics == test_stats assert coordinator.statistics == test_stats
assert coordinator.protection_status == test_status assert coordinator.protection_status == test_status
# ENHANCED TESTS FOR BETTER COVERAGE def test_coordinator_properties_empty_data(self, mock_hass, mock_api):
@pytest.mark.asyncio """Test coordinator properties with empty data."""
async def test_switch_platform_setup(self, mock_hass, mock_config_entry, mock_coordinator, mock_api): coordinator = AdGuardControlHubCoordinator(mock_hass, mock_api)
"""Test switch platform setup."""
from custom_components.adguard_hub.switch import async_setup_entry
mock_hass.data[DOMAIN] = { # Properties should return empty containers, not None
mock_config_entry.entry_id: { assert coordinator.clients == {}
"coordinator": mock_coordinator, assert coordinator.statistics == {}
"api": mock_api assert coordinator.protection_status == {}
}
}
mock_add_entities = MagicMock()
await async_setup_entry(mock_hass, mock_config_entry, mock_add_entities)
# Should add protection switch and client switches class TestServices:
assert mock_add_entities.called """Test service functionality."""
entities = mock_add_entities.call_args[0][0]
assert len(entities) >= 1 # At least protection switch def test_services_registration(self, mock_hass):
"""Test that services are properly registered."""
from custom_components.adguard_hub.services import AdGuardControlHubServices
services = AdGuardControlHubServices(mock_hass)
services.register_services()
# Verify services registration was called
assert mock_hass.services.register.called
# Verify correct number of service registrations
expected_call_count = 6 # block_services, unblock_services, emergency_unblock, add_client, remove_client, refresh_data
assert mock_hass.services.register.call_count == expected_call_count
def test_services_unregistration(self, mock_hass):
"""Test that services are properly unregistered."""
from custom_components.adguard_hub.services import AdGuardControlHubServices
# Mock service existence
mock_hass.services.has_service.return_value = True
services = AdGuardControlHubServices(mock_hass)
services.unregister_services()
# Verify correct number of service removals
expected_call_count = 6
assert mock_hass.services.remove.call_count == expected_call_count
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_sensor_platform_setup(self, mock_hass, mock_config_entry, mock_coordinator, mock_api): async def test_block_services_success(self, mock_hass, mock_api):
"""Test sensor platform setup.""" """Test successful service blocking."""
from custom_components.adguard_hub.sensor import async_setup_entry from custom_components.adguard_hub.services import AdGuardControlHubServices
mock_hass.data[DOMAIN] = { mock_hass.data[DOMAIN] = {
mock_config_entry.entry_id: { "entry_id": {"api": mock_api}
"coordinator": mock_coordinator,
"api": mock_api
}
} }
mock_add_entities = MagicMock() services = AdGuardControlHubServices(mock_hass)
await async_setup_entry(mock_hass, mock_config_entry, mock_add_entities) call = MagicMock()
call.data = {
"client_name": "test_client",
"services": ["youtube", "netflix"]
}
# Should add multiple sensors await services.block_services(call)
assert mock_add_entities.called
entities = mock_add_entities.call_args[0][0] mock_api.get_client_by_name.assert_called_once_with("test_client")
assert len(entities) >= 6 # Multiple sensors mock_api.update_client_blocked_services.assert_called_once()
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_binary_sensor_platform_setup(self, mock_hass, mock_config_entry, mock_coordinator, mock_api): async def test_unblock_services_success(self, mock_hass, mock_api):
"""Test binary sensor platform setup.""" """Test successful service unblocking."""
from custom_components.adguard_hub.binary_sensor import async_setup_entry from custom_components.adguard_hub.services import AdGuardControlHubServices
mock_hass.data[DOMAIN] = { mock_hass.data[DOMAIN] = {
mock_config_entry.entry_id: { "entry_id": {"api": mock_api}
"coordinator": mock_coordinator,
"api": mock_api
}
} }
mock_add_entities = MagicMock() services = AdGuardControlHubServices(mock_hass)
await async_setup_entry(mock_hass, mock_config_entry, mock_add_entities) call = MagicMock()
call.data = {
"client_name": "test_client",
"services": ["youtube"]
}
# Should add multiple binary sensors await services.unblock_services(call)
assert mock_add_entities.called
entities = mock_add_entities.call_args[0][0] mock_api.get_client_by_name.assert_called_once_with("test_client")
assert len(entities) >= 5 # Multiple binary sensors mock_api.update_client_blocked_services.assert_called_once()
@pytest.mark.asyncio
async def test_emergency_unblock_global(self, mock_hass, mock_api):
"""Test emergency unblock for all clients."""
from custom_components.adguard_hub.services import AdGuardControlHubServices
mock_hass.data[DOMAIN] = {
"entry_id": {"api": mock_api}
}
services = AdGuardControlHubServices(mock_hass)
call = MagicMock()
call.data = {
"duration": 300,
"clients": ["all"]
}
await services.emergency_unblock(call)
mock_api.set_protection.assert_called_once_with(False)
@pytest.mark.asyncio
async def test_refresh_data_success(self, mock_hass, mock_coordinator):
"""Test successful data refresh."""
from custom_components.adguard_hub.services import AdGuardControlHubServices
mock_hass.data[DOMAIN] = {
"entry_id": {"coordinator": mock_coordinator}
}
services = AdGuardControlHubServices(mock_hass)
call = MagicMock()
call.data = {}
await services.refresh_data(call)
mock_coordinator.async_request_refresh.assert_called_once()
class TestConstants:
"""Test constant definitions."""
def test_blocked_services_constants(self):
"""Test that blocked services are properly defined."""
from custom_components.adguard_hub.const import BLOCKED_SERVICES
required_services = ["youtube", "netflix", "gaming", "facebook"]
for service in required_services:
assert service in BLOCKED_SERVICES
assert isinstance(BLOCKED_SERVICES[service], str)
assert len(BLOCKED_SERVICES[service]) > 0
def test_api_endpoints_constants(self):
"""Test that API endpoints are properly defined."""
from custom_components.adguard_hub.const import API_ENDPOINTS
required_endpoints = [
"status", "clients", "stats", "protection",
"clients_add", "clients_update", "clients_delete"
]
for endpoint in required_endpoints:
assert endpoint in API_ENDPOINTS
assert API_ENDPOINTS[endpoint].startswith("/")
def test_platform_constants(self):
"""Test platform constants."""
from custom_components.adguard_hub.const import PLATFORMS
expected_platforms = ["switch", "binary_sensor", "sensor"]
assert PLATFORMS == expected_platforms
def test_service_constants(self):
"""Test service name constants."""
from custom_components.adguard_hub.const import (
SERVICE_BLOCK_SERVICES,
SERVICE_UNBLOCK_SERVICES,
SERVICE_EMERGENCY_UNBLOCK,
SERVICE_ADD_CLIENT,
SERVICE_REMOVE_CLIENT,
SERVICE_REFRESH_DATA,
)
services = [
SERVICE_BLOCK_SERVICES,
SERVICE_UNBLOCK_SERVICES,
SERVICE_EMERGENCY_UNBLOCK,
SERVICE_ADD_CLIENT,
SERVICE_REMOVE_CLIENT,
SERVICE_REFRESH_DATA,
]
for service in services:
assert isinstance(service, str)
assert len(service) > 0
assert "_" in service # Snake case format