"""
Fixed Unit tests for the Unimus REST API client library.
Tests the UnimusRestClient class with proper mocking following Gemini's guidance.
Focus on mocking session.get/post methods and actual API methods rather than non-existent _make_request.
"""
import pytest
from unittest.mock import Mock, patch, MagicMock
import requests
from typing import Dict, List, Any
import json
from unimus_client import (
UnimusRestClient,
UnimusError,
UnimusNotFoundError,
UnimusValidationError,
UnimusAuthenticationError
)
from config import UnimusConfig
from tests.fixtures.mock_data import MockDataFactory
class TestUnimusRestClientFixed:
"""Test UnimusRestClient with correct mocking patterns."""
@pytest.fixture
def client(self):
"""Create a test client."""
return UnimusRestClient(
url="https://test.unimus.com",
token="test-token",
timeout=30
)
@pytest.fixture
def mock_devices_response(self):
"""Mock devices API response."""
return {
"data": [
{"id": 1, "address": "10.0.0.1", "type": "switch", "vendor": "Cisco"},
{"id": 2, "address": "10.0.0.2", "type": "router", "vendor": "Juniper"}
],
"paginator": {"current_page": 1, "total_pages": 1, "total_results": 2}
}
@pytest.fixture
def mock_device_response(self):
"""Mock single device API response."""
return {
"data": {
"id": 1,
"address": "10.0.0.1",
"type": "switch",
"vendor": "Cisco",
"connections": [{"type": "SSH", "port": 22}]
}
}
@pytest.fixture
def mock_health_response(self):
"""Mock health API response."""
return {"status": "OK", "version": "1.0"}
def test_client_initialization(self, client):
"""Test proper client initialization."""
assert client.base_url == "https://test.unimus.com"
assert client.api_url == "https://test.unimus.com/api/v2"
assert client.session.headers["Authorization"] == "Bearer test-token"
assert client.timeout == 30
assert client.verify_ssl == True
def test_build_url(self, client):
"""Test URL building functionality."""
assert client._build_url("devices") == "https://test.unimus.com/api/v2/devices"
assert client._build_url("/devices") == "https://test.unimus.com/api/v2/devices"
assert client._build_url("devices/") == "https://test.unimus.com/api/v2/devices"
assert client._build_url("/devices/") == "https://test.unimus.com/api/v2/devices"
def test_get_health_success(self, client, mock_health_response):
"""Test successful health check."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_health_response
with patch.object(client.session, 'get', return_value=mock_response):
result = client.get_health()
assert result == mock_health_response
client.session.get.assert_called_once()
def test_get_devices_success(self, client, mock_devices_response):
"""Test successful devices retrieval."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_devices_response
with patch.object(client.session, 'get', return_value=mock_response):
result = client.get_devices()
assert len(result) == 2
assert result[0]["id"] == 1
assert result[1]["id"] == 2
client.session.get.assert_called_once()
def test_get_device_by_id_success(self, client, mock_device_response):
"""Test successful device retrieval by ID."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_device_response
with patch.object(client.session, 'get', return_value=mock_response):
result = client.get_device_by_id(1)
assert result["id"] == 1
assert result["address"] == "10.0.0.1"
client.session.get.assert_called_once()
def test_get_device_by_id_with_attributes(self, client, mock_device_response):
"""Test device retrieval with flexible attributes."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_device_response
with patch.object(client.session, 'get', return_value=mock_response):
# Test with schedule attribute
result = client.get_device_by_id(1, include_attributes=['schedule'])
assert result["id"] == 1
# Test with connections attribute
result = client.get_device_by_id(1, include_attributes=['connections'])
assert result["id"] == 1
# Test with both attributes
result = client.get_device_by_id(1, include_attributes=['schedule', 'connections'])
assert result["id"] == 1
def test_error_handling_404(self, client):
"""Test 404 Not Found error handling."""
mock_response = Mock()
mock_response.status_code = 404
mock_response.json.return_value = {"message": "Device not found"}
with patch.object(client.session, 'get', return_value=mock_response):
with pytest.raises(UnimusNotFoundError, match="Device not found"):
client.get_device_by_id(999)
def test_error_handling_401(self, client):
"""Test 401 Unauthorized error handling."""
mock_response = Mock()
mock_response.status_code = 401
mock_response.json.return_value = {"message": "Unauthorized"}
with patch.object(client.session, 'get', return_value=mock_response):
with pytest.raises(UnimusAuthenticationError, match="Unauthorized"):
client.get_health()
def test_error_handling_400(self, client):
"""Test 400 Bad Request error handling."""
mock_response = Mock()
mock_response.status_code = 400
mock_response.json.return_value = {"message": "Invalid request"}
with patch.object(client.session, 'get', return_value=mock_response):
with pytest.raises(UnimusValidationError, match="Invalid request"):
client.get_device_by_id(-1)
def test_error_handling_500(self, client):
"""Test 500 Internal Server Error handling."""
mock_response = Mock()
mock_response.status_code = 500
mock_response.json.return_value = {"message": "Server error"}
with patch.object(client.session, 'get', return_value=mock_response):
with pytest.raises(UnimusError, match="Server error"):
client.get_health()
def test_validate_connection_success(self, client, mock_health_response):
"""Test connection validation success."""
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_health_response
with patch.object(client.session, 'get', return_value=mock_response):
result = client.validate_connection()
assert result == True
def test_validate_connection_failure(self, client):
"""Test connection validation failure."""
mock_response = Mock()
mock_response.status_code = 401
mock_response.json.return_value = {"message": "Unauthorized"}
with patch.object(client.session, 'get', return_value=mock_response):
result = client.validate_connection()
assert result == False
def test_get_device_backups(self, client):
"""Test device backups retrieval."""
mock_backups_response = {
"data": [
{"id": 1, "device_id": 1, "timestamp": 1640995200},
{"id": 2, "device_id": 1, "timestamp": 1640995260}
],
"paginator": {"current_page": 1, "total_pages": 1, "total_results": 2}
}
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_backups_response
with patch.object(client.session, 'get', return_value=mock_response):
result = client.get_device_backups(1)
assert len(result) == 2
assert all(backup["device_id"] == 1 for backup in result)
def test_get_backup_by_id(self, client):
"""Test backup retrieval by ID."""
mock_backup_response = {
"data": {
"id": 1,
"device_id": 1,
"timestamp": 1640995200,
"content": "aGVsbG8gd29ybGQ=" # base64 encoded "hello world"
}
}
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = mock_backup_response
with patch.object(client.session, 'get', return_value=mock_response):
result = client.get_backup_by_id(1)
assert result["id"] == 1
assert result["device_id"] == 1
# The method should process the backup response
assert "content" in result
def test_search_backup_content_simple(self, client):
"""Test backup content search with simplified mocking."""
expected_results = [
{
"device": {"id": 1, "address": "10.0.0.1"},
"matches": [
{
"line_number": 5,
"line_content": "interface GigabitEthernet0/1",
"context_before": [],
"context_after": [],
"match_groups": []
}
]
}
]
# Mock the entire search_backup_content method
with patch.object(client, 'search_backup_content', return_value=expected_results):
result = client.search_backup_content("interface.*", limit=10)
assert len(result) == 1
assert result[0]["device"]["id"] == 1
assert len(result[0]["matches"]) == 1
