test_update_service_dns.py

#!/usr/bin/env python3
"""Tests for update_service_dns.py.

This module tests Cloudflare DNS record management for Kubernetes services
based on their Headscale VPN IPs.
"""

import json
import os
import subprocess
from unittest.mock import MagicMock

from pytest_mock import MockFixture

# Set DOMAIN_NAME before importing the module
os.environ["DOMAIN_NAME"] = "test.example.com"

from scripts.dns.update_service_dns import (
    create_dns_record,
    delete_dns_record,
    get_cloudflare_record,
    get_cloudflare_records,
    get_node_ip,
    get_pod_ip,
    process_service,
    update_dns_record,
)


class TestGetPodIp:
    """Tests for get_pod_ip function."""

    def test_get_pod_ip_success(self, mocker: MockFixture) -> None:
        """Test successful IP retrieval for online node."""
        nodes_output = [
            {
                "name": "grafana-0",
                "online": True,
                "ip_addresses": ["100.64.0.5", "fd7a:115c:a1e0::5"],
            },
            {
                "name": "redmine-0",
                "online": True,
                "ip_addresses": ["100.64.0.6"],
            },
        ]

        mock_run = mocker.patch("subprocess.run")
        mock_run.return_value = MagicMock(stdout=json.dumps(nodes_output), returncode=0)

        result = get_pod_ip("dev", "grafana-0")

        assert result == "100.64.0.5"
        mock_run.assert_called_once()

    def test_get_pod_ip_excludes_ipv6(self, mocker: MockFixture) -> None:
        """Test that IPv6 addresses are excluded."""
        nodes_output = [
            {
                "name": "grafana-0",
                "online": True,
                "ip_addresses": ["fd7a:115c:a1e0::5", "100.64.0.5"],
            },
        ]

        mock_run = mocker.patch("subprocess.run")
        mock_run.return_value = MagicMock(stdout=json.dumps(nodes_output), returncode=0)

        result = get_pod_ip("dev", "grafana-0")

        # Should return the IPv4 address, not the IPv6
        assert result == "100.64.0.5"

    def test_get_pod_ip_offline_node(self, mocker: MockFixture) -> None:
        """Test that offline nodes return None."""
        nodes_output = [
            {
                "name": "grafana-0",
                "online": False,
                "ip_addresses": ["100.64.0.5"],
            },
        ]

        mock_run = mocker.patch("subprocess.run")
        mock_run.return_value = MagicMock(stdout=json.dumps(nodes_output), returncode=0)

        result = get_pod_ip("dev", "grafana-0")

        assert result is None

    def test_get_pod_ip_not_found(self, mocker: MockFixture) -> None:
        """Test when hostname is not in node list."""
        nodes_output = [
            {
                "name": "other-service-0",
                "online": True,
                "ip_addresses": ["100.64.0.5"],
            },
        ]

        mock_run = mocker.patch("subprocess.run")
        mock_run.return_value = MagicMock(stdout=json.dumps(nodes_output), returncode=0)

        result = get_pod_ip("dev", "grafana-0")

        assert result is None

    def test_get_pod_ip_kubectl_failure(self, mocker: MockFixture) -> None:
        """Test handling kubectl command failure."""
        mock_run = mocker.patch("subprocess.run")
        mock_run.side_effect = subprocess.CalledProcessError(1, ["kubectl"], stderr="connection refused")

        result = get_pod_ip("dev", "grafana-0")

        assert result is None

    def test_get_pod_ip_invalid_json(self, mocker: MockFixture) -> None:
        """Test handling invalid JSON response."""
        mock_run = mocker.patch("subprocess.run")
        mock_run.return_value = MagicMock(stdout="not valid json", returncode=0)

        result = get_pod_ip("dev", "grafana-0")

        assert result is None


class TestGetNodeIp:
    """Tests for get_node_ip function."""

    def test_get_node_ip_external(self, mocker: MockFixture) -> None:
        """Test retrieving external IP."""
        mock_run = mocker.patch("subprocess.run")
        mock_run.return_value = MagicMock(stdout="203.0.113.10", returncode=0)

        result = get_node_ip()

        assert result == "203.0.113.10"

    def test_get_node_ip_fallback_internal(self, mocker: MockFixture) -> None:
        """Test fallback to internal IP when no external IP."""
        mock_run = mocker.patch("subprocess.run")
        # First call returns empty (no external IP), second returns internal IP
        mock_run.side_effect = [
            MagicMock(stdout="", returncode=0),
            MagicMock(stdout="10.0.0.5", returncode=0),
        ]

        result = get_node_ip()

        assert result == "10.0.0.5"
        assert mock_run.call_count == 2

    def test_get_node_ip_none_available(self, mocker: MockFixture) -> None:
        """Test when no IP is available."""
        mock_run = mocker.patch("subprocess.run")
        mock_run.side_effect = [
            MagicMock(stdout="", returncode=0),
            MagicMock(stdout="", returncode=0),
        ]

        result = get_node_ip()

        assert result is None

    def test_get_node_ip_kubectl_failure(self, mocker: MockFixture) -> None:
        """Test handling kubectl failure."""
        mock_run = mocker.patch("subprocess.run")
        mock_run.side_effect = subprocess.CalledProcessError(1, ["kubectl"])

        result = get_node_ip()

        assert result is None


class TestGetCloudflareRecords:
    """Tests for Cloudflare record retrieval functions."""

    def test_get_cloudflare_records_success(self, mocker: MockFixture) -> None:
        """Test successful record retrieval."""
        mock_response = MagicMock()
        mock_response.json.return_value = {
            "success": True,
            "result": [
                {"id": "record1", "content": "100.64.0.5", "name": "grafana.test.example.com"},
                {"id": "record2", "content": "100.64.0.6", "name": "grafana.test.example.com"},
            ],
        }
        mock_response.raise_for_status = MagicMock()

        mock_get = mocker.patch("requests.get", return_value=mock_response)

        result = get_cloudflare_records("test-token", "zone123", "grafana")

        assert len(result) == 2
        assert result[0]["id"] == "record1"
        mock_get.assert_called_once()

    def test_get_cloudflare_records_empty(self, mocker: MockFixture) -> None:
        """Test when no records exist."""
        mock_response = MagicMock()
        mock_response.json.return_value = {"success": True, "result": []}
        mock_response.raise_for_status = MagicMock()

        mocker.patch("requests.get", return_value=mock_response)

        result = get_cloudflare_records("test-token", "zone123", "grafana")

        assert result == []

    def test_get_cloudflare_records_api_error(self, mocker: MockFixture) -> None:
        """Test handling Cloudflare API error."""
        mock_response = MagicMock()
        mock_response.raise_for_status.side_effect = Exception("API Error")

        mocker.patch("requests.get", return_value=mock_response)

        result = get_cloudflare_records("test-token", "zone123", "grafana")

        assert result == []

    def test_get_cloudflare_record_returns_first(self, mocker: MockFixture) -> None:
        """Test get_cloudflare_record returns first record."""
        mock_response = MagicMock()
        mock_response.json.return_value = {
            "success": True,
            "result": [
                {"id": "record1", "content": "100.64.0.5"},
                {"id": "record2", "content": "100.64.0.6"},
            ],
        }
        mock_response.raise_for_status = MagicMock()

        mocker.patch("requests.get", return_value=mock_response)

        result = get_cloudflare_record("test-token", "zone123", "grafana")

        assert result is not None
        assert result["id"] == "record1"

    def test_get_cloudflare_record_returns_none_when_empty(self, mocker: MockFixture) -> None:
        """Test get_cloudflare_record returns None when no records."""
        mock_response = MagicMock()
        mock_response.json.return_value = {"success": True, "result": []}
        mock_response.raise_for_status = MagicMock()

        mocker.patch("requests.get", return_value=mock_response)

        result = get_cloudflare_record("test-token", "zone123", "grafana")

        assert result is None


class TestCreateDnsRecord:
    """Tests for create_dns_record function."""

    def test_create_dns_record_success(self, mocker: MockFixture) -> None:
        """Test successful record creation."""
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"success": True}

        mock_post = mocker.patch("requests.post", return_value=mock_response)

        result = create_dns_record("test-token", "zone123", "grafana", "100.64.0.5")

        assert result is True
        mock_post.assert_called_once()

        # Verify the request payload
        call_args = mock_post.call_args
        assert call_args.kwargs["json"]["type"] == "A"
        assert call_args.kwargs["json"]["name"] == "grafana"
        assert call_args.kwargs["json"]["content"] == "100.64.0.5"

    def test_create_dns_record_dry_run(self, mocker: MockFixture) -> None:
        """Test dry run mode doesn't make API calls."""
        mock_post = mocker.patch("requests.post")

        result = create_dns_record("test-token", "zone123", "grafana", "100.64.0.5", dry_run=True)

        assert result is True
        mock_post.assert_not_called()

    def test_create_dns_record_api_failure(self, mocker: MockFixture) -> None:
        """Test handling API failure."""
        mock_response = MagicMock()
        mock_response.status_code = 400
        mock_response.json.return_value = {"success": False, "errors": ["Invalid"]}

        mocker.patch("requests.post", return_value=mock_response)

        result = create_dns_record("test-token", "zone123", "grafana", "100.64.0.5")

        assert result is False

    def test_create_dns_record_exception(self, mocker: MockFixture) -> None:
        """Test handling request exception."""
        mocker.patch("requests.post", side_effect=Exception("Network error"))

        result = create_dns_record("test-token", "zone123", "grafana", "100.64.0.5")

        assert result is False


class TestUpdateDnsRecord:
    """Tests for update_dns_record function."""

    def test_update_dns_record_success(self, mocker: MockFixture) -> None:
        """Test successful record update."""
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"success": True}

        mock_put = mocker.patch("requests.put", return_value=mock_response)

        result = update_dns_record("test-token", "zone123", "record1", "grafana", "100.64.0.5", "100.64.0.10")

        assert result is True
        mock_put.assert_called_once()

    def test_update_dns_record_dry_run(self, mocker: MockFixture) -> None:
        """Test dry run mode doesn't make API calls."""
        mock_put = mocker.patch("requests.put")

        result = update_dns_record(
            "test-token",
            "zone123",
            "record1",
            "grafana",
            "100.64.0.5",
            "100.64.0.10",
            dry_run=True,
        )

        assert result is True
        mock_put.assert_not_called()

    def test_update_dns_record_api_failure(self, mocker: MockFixture) -> None:
        """Test handling API failure."""
        mock_response = MagicMock()
        mock_response.status_code = 400
        mock_response.json.return_value = {"success": False}

        mocker.patch("requests.put", return_value=mock_response)

        result = update_dns_record("test-token", "zone123", "record1", "grafana", "100.64.0.5", "100.64.0.10")

        assert result is False


class TestDeleteDnsRecord:
    """Tests for delete_dns_record function."""

    def test_delete_dns_record_success(self, mocker: MockFixture) -> None:
        """Test successful record deletion."""
        mock_response = MagicMock()
        mock_response.status_code = 200
        mock_response.json.return_value = {"success": True}

        mock_delete = mocker.patch("requests.delete", return_value=mock_response)

        result = delete_dns_record("test-token", "zone123", "record1", "grafana", "100.64.0.5")

        assert result is True
        mock_delete.assert_called_once()

    def test_delete_dns_record_dry_run(self, mocker: MockFixture) -> None:
        """Test dry run mode doesn't make API calls."""
        mock_delete = mocker.patch("requests.delete")

        result = delete_dns_record("test-token", "zone123", "record1", "grafana", "100.64.0.5", dry_run=True)

        assert result is True
        mock_delete.assert_not_called()

    def test_delete_dns_record_api_failure(self, mocker: MockFixture) -> None:
        """Test handling API failure."""
        mock_response = MagicMock()
        mock_response.status_code = 404
        mock_response.json.return_value = {"success": False, "errors": ["Not found"]}

        mocker.patch("requests.delete", return_value=mock_response)

        result = delete_dns_record("test-token", "zone123", "record1", "grafana", "100.64.0.5")

        assert result is False


class TestProcessService:
    """Tests for process_service function."""

    def test_process_service_disabled(self, mocker: MockFixture) -> None:
        """Test that disabled services are skipped."""
        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": False,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is True  # Skipped services return True

    def test_process_service_no_pod_ip(self, mocker: MockFixture) -> None:
        """Test failure when pod IP not found."""
        mocker.patch("scripts.dns.update_service_dns.get_pod_ip", return_value=None)

        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": True,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is False

    def test_process_service_create_new_record(self, mocker: MockFixture) -> None:
        """Test creating a new DNS record when none exists."""
        mocker.patch("scripts.dns.update_service_dns.get_pod_ip", return_value="100.64.0.5")
        mocker.patch("scripts.dns.update_service_dns.get_cloudflare_records", return_value=[])
        mock_create = mocker.patch("scripts.dns.update_service_dns.create_dns_record", return_value=True)

        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": True,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is True
        mock_create.assert_called_once_with("test-token", "zone123", "grafana", "100.64.0.5", False)

    def test_process_service_update_existing_record(self, mocker: MockFixture) -> None:
        """Test updating an existing DNS record with changed IP."""
        mocker.patch("scripts.dns.update_service_dns.get_pod_ip", return_value="100.64.0.10")
        mocker.patch(
            "scripts.dns.update_service_dns.get_cloudflare_records",
            return_value=[{"id": "record1", "content": "100.64.0.5"}],
        )
        mock_update = mocker.patch("scripts.dns.update_service_dns.update_dns_record", return_value=True)

        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": True,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is True
        mock_update.assert_called_once()

    def test_process_service_record_already_correct(self, mocker: MockFixture) -> None:
        """Test skipping update when record is already correct."""
        mocker.patch("scripts.dns.update_service_dns.get_pod_ip", return_value="100.64.0.5")
        mocker.patch(
            "scripts.dns.update_service_dns.get_cloudflare_records",
            return_value=[{"id": "record1", "content": "100.64.0.5"}],
        )
        mock_update = mocker.patch("scripts.dns.update_service_dns.update_dns_record")
        mock_create = mocker.patch("scripts.dns.update_service_dns.create_dns_record")

        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": True,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is True
        mock_update.assert_not_called()
        mock_create.assert_not_called()

    def test_process_service_cleanup_multiple_records(self, mocker: MockFixture) -> None:
        """Test cleanup of multiple stale DNS records."""
        mocker.patch("scripts.dns.update_service_dns.get_pod_ip", return_value="100.64.0.10")
        mocker.patch(
            "scripts.dns.update_service_dns.get_cloudflare_records",
            return_value=[
                {"id": "record1", "content": "100.64.0.5"},  # stale
                {"id": "record2", "content": "100.64.0.6"},  # stale
                {"id": "record3", "content": "100.64.0.10"},  # correct
            ],
        )
        mock_delete = mocker.patch("scripts.dns.update_service_dns.delete_dns_record", return_value=True)

        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": True,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is True
        # Should delete 2 stale records
        assert mock_delete.call_count == 2

    def test_process_service_multiple_records_none_correct(self, mocker: MockFixture) -> None:
        """Test cleanup and create when multiple records exist but none match."""
        mocker.patch("scripts.dns.update_service_dns.get_pod_ip", return_value="100.64.0.10")
        mocker.patch(
            "scripts.dns.update_service_dns.get_cloudflare_records",
            return_value=[
                {"id": "record1", "content": "100.64.0.5"},
                {"id": "record2", "content": "100.64.0.6"},
            ],
        )
        mock_delete = mocker.patch("scripts.dns.update_service_dns.delete_dns_record", return_value=True)
        mock_create = mocker.patch("scripts.dns.update_service_dns.create_dns_record", return_value=True)

        service = {
            "name": "grafana",
            "hostname": "grafana-0",
            "record_name": "grafana",
            "enabled": True,
        }

        result = process_service("test-token", "zone123", "dev", service)

        assert result is True
        assert mock_delete.call_count == 2
        mock_create.assert_called_once()