pic/tests/test_logs_endpoints.py

#!/usr/bin/env python3
"""
Unit tests for logs Flask endpoints in api/app.py.

Covers:
  GET  /api/logs                           — backend log file (reads picell.log)
  GET  /api/logs/services/<service>        — per-service logs via log_manager
  POST /api/logs/search                    — search across services
  POST /api/logs/export                    — export logs
  GET  /api/logs/statistics                — log stats
  POST /api/logs/rotate                    — rotate logs
  GET  /api/logs/files                     — list log file info
  GET  /api/logs/verbosity                 — get log levels
  PUT  /api/logs/verbosity                 — set log levels
"""

import sys
import json
import os
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch, MagicMock, mock_open

api_dir = Path(__file__).parent.parent / 'api'
sys.path.insert(0, str(api_dir))

from app import app


class TestGetBackendLogs(unittest.TestCase):
    """GET /api/logs — reads picell.log from api directory."""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    def test_get_logs_returns_404_when_log_file_missing(self):
        # Patch os.path.exists so the log file appears absent
        with patch('app.os.path.exists', return_value=False):
            r = self.client.get('/api/logs')
        self.assertEqual(r.status_code, 404)
        self.assertIn('error', json.loads(r.data))

    def test_get_logs_returns_200_with_log_content(self):
        log_content = 'INFO 2026-04-27 server started\nERROR something went wrong\n'
        m = mock_open(read_data=log_content)
        # Bypass auth enforcement by replacing auth_manager with a non-AuthManager object
        with patch('app.auth_manager', MagicMock(spec=object)), \
             patch('app.os.path.exists', return_value=True), \
             patch('builtins.open', m):
            r = self.client.get('/api/logs')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertIn('log', data)

    def test_get_logs_respects_lines_query_param(self):
        # Produce 10 lines; request only last 3
        all_lines = [f'line {i}\n' for i in range(10)]
        m = mock_open(read_data=''.join(all_lines))
        m.return_value.__iter__ = lambda s: iter(all_lines)
        m.return_value.readlines = lambda: all_lines
        # Bypass auth enforcement by replacing auth_manager with a non-AuthManager object
        with patch('app.auth_manager', MagicMock(spec=object)), \
             patch('app.os.path.exists', return_value=True), \
             patch('builtins.open', m):
            r = self.client.get('/api/logs?lines=3')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        # The tail should contain only the last 3 lines
        self.assertIn('line 7', data['log'])
        self.assertIn('line 8', data['log'])
        self.assertIn('line 9', data['log'])

    def test_get_logs_returns_500_on_exception(self):
        with patch('app.os.path.exists', return_value=True), \
             patch('builtins.open', side_effect=PermissionError('access denied')):
            r = self.client.get('/api/logs')
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))

    def test_get_logs_level_filter_returns_only_matching(self):
        lines = [
            json.dumps({'level': 'INFO', 'message': 'started'}) + '\n',
            json.dumps({'level': 'ERROR', 'message': 'boom'}) + '\n',
            json.dumps({'level': 'INFO', 'message': 'ok'}) + '\n',
            json.dumps({'level': 'ERROR', 'message': 'kaboom'}) + '\n',
        ]
        m = mock_open(read_data=''.join(lines))
        m.return_value.readlines = lambda: lines
        with patch('app.auth_manager', MagicMock(spec=object)), \
             patch('app.os.path.exists', return_value=True), \
             patch('builtins.open', m):
            r = self.client.get('/api/logs?level=ERROR')
        self.assertEqual(r.status_code, 200)
        out = json.loads(r.data)['log']
        self.assertIn('boom', out)
        self.assertIn('kaboom', out)
        self.assertNotIn('started', out)
        self.assertNotIn('"message": "ok"', out)


class TestGetServiceLogs(unittest.TestCase):
    """GET /api/logs/services/<service>"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.log_manager')
    def test_get_service_logs_returns_200_with_log_data(self, mock_lm):
        mock_lm.get_service_logs.return_value = [
            '[INFO] 2026-04-27 dns started',
            '[WARN] 2026-04-27 retry attempt',
        ]
        r = self.client.get('/api/logs/services/dns')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertEqual(data['service'], 'dns')
        self.assertIsInstance(data['logs'], list)
        self.assertEqual(len(data['logs']), 2)

    @patch('app.log_manager')
    def test_get_service_logs_passes_level_and_lines_params(self, mock_lm):
        mock_lm.get_service_logs.return_value = []
        self.client.get('/api/logs/services/email?level=ERROR&lines=25')
        mock_lm.get_service_logs.assert_called_once_with('email', 'ERROR', 25)

    @patch('app.log_manager')
    def test_get_service_logs_uses_defaults_when_params_absent(self, mock_lm):
        mock_lm.get_service_logs.return_value = []
        self.client.get('/api/logs/services/wireguard')
        mock_lm.get_service_logs.assert_called_once_with('wireguard', 'INFO', 50)

    @patch('app.log_manager')
    def test_get_service_logs_returns_500_on_exception(self, mock_lm):
        mock_lm.get_service_logs.side_effect = Exception('log file missing')
        r = self.client.get('/api/logs/services/calendar')
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))


class TestSearchLogs(unittest.TestCase):
    """POST /api/logs/search"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.log_manager')
    def test_search_logs_returns_200_with_results_and_count(self, mock_lm):
        mock_lm.search_logs.return_value = [
            {'service': 'dns', 'line': 'ERROR timeout'},
        ]
        r = self.client.post(
            '/api/logs/search',
            data=json.dumps({'query': 'ERROR', 'services': ['dns']}),
            content_type='application/json',
        )
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertIn('results', data)
        self.assertIn('count', data)
        self.assertEqual(data['count'], 1)

    @patch('app.log_manager')
    def test_search_logs_works_with_empty_body(self, mock_lm):
        mock_lm.search_logs.return_value = []
        r = self.client.post('/api/logs/search')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertEqual(data['results'], [])
        self.assertEqual(data['count'], 0)

    @patch('app.log_manager')
    def test_search_logs_returns_500_on_exception(self, mock_lm):
        mock_lm.search_logs.side_effect = Exception('index unavailable')
        r = self.client.post(
            '/api/logs/search',
            data=json.dumps({'query': 'fail'}),
            content_type='application/json',
        )
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))


class TestExportLogs(unittest.TestCase):
    """POST /api/logs/export"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.log_manager')
    def test_export_logs_returns_200_with_log_data_and_format(self, mock_lm):
        mock_lm.export_logs.return_value = '[{"ts":1,"msg":"ok"}]'
        r = self.client.post(
            '/api/logs/export',
            data=json.dumps({'format': 'json', 'filters': {'service': 'dns'}}),
            content_type='application/json',
        )
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertIn('logs', data)
        self.assertIn('format', data)
        self.assertEqual(data['format'], 'json')

    @patch('app.log_manager')
    def test_export_logs_defaults_to_json_format(self, mock_lm):
        mock_lm.export_logs.return_value = '[]'
        self.client.post('/api/logs/export')
        mock_lm.export_logs.assert_called_once_with('json', {})

    @patch('app.log_manager')
    def test_export_logs_returns_500_on_exception(self, mock_lm):
        mock_lm.export_logs.side_effect = Exception('export failed')
        r = self.client.post(
            '/api/logs/export',
            data=json.dumps({'format': 'csv'}),
            content_type='application/json',
        )
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))


class TestGetLogStatistics(unittest.TestCase):
    """GET /api/logs/statistics"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.log_manager')
    def test_get_statistics_returns_200_with_stats_dict(self, mock_lm):
        mock_lm.get_log_statistics.return_value = {
            'total_lines': 1200,
            'error_count': 3,
            'warn_count': 17,
        }
        r = self.client.get('/api/logs/statistics')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertIn('total_lines', data)

    @patch('app.log_manager')
    def test_get_statistics_passes_service_param(self, mock_lm):
        mock_lm.get_log_statistics.return_value = {}
        self.client.get('/api/logs/statistics?service=email')
        mock_lm.get_log_statistics.assert_called_once_with('email')

    @patch('app.log_manager')
    def test_get_statistics_passes_none_when_no_service_param(self, mock_lm):
        mock_lm.get_log_statistics.return_value = {}
        self.client.get('/api/logs/statistics')
        mock_lm.get_log_statistics.assert_called_once_with(None)

    @patch('app.log_manager')
    def test_get_statistics_returns_500_on_exception(self, mock_lm):
        mock_lm.get_log_statistics.side_effect = Exception('stats error')
        r = self.client.get('/api/logs/statistics')
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))


class TestRotateLogs(unittest.TestCase):
    """POST /api/logs/rotate"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.log_manager')
    def test_rotate_all_logs_returns_200(self, mock_lm):
        r = self.client.post('/api/logs/rotate')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertIn('message', data)
        mock_lm.rotate_logs.assert_called_once_with(None)

    @patch('app.log_manager')
    def test_rotate_specific_service_passes_service_name(self, mock_lm):
        r = self.client.post(
            '/api/logs/rotate',
            data=json.dumps({'service': 'dns'}),
            content_type='application/json',
        )
        self.assertEqual(r.status_code, 200)
        mock_lm.rotate_logs.assert_called_once_with('dns')

    @patch('app.log_manager')
    def test_rotate_returns_500_on_exception(self, mock_lm):
        mock_lm.rotate_logs.side_effect = Exception('rotate failed')
        r = self.client.post('/api/logs/rotate')
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))


class TestGetLogFileInfos(unittest.TestCase):
    """GET /api/logs/files"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.log_manager')
    def test_get_log_files_returns_200_with_file_list(self, mock_lm):
        mock_lm.get_all_log_file_infos.return_value = [
            {'service': 'dns', 'path': '/data/logs/dns.log', 'size_bytes': 4096},
            {'service': 'email', 'path': '/data/logs/email.log', 'size_bytes': 8192},
        ]
        r = self.client.get('/api/logs/files')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertIsInstance(data, list)
        self.assertEqual(len(data), 2)

    @patch('app.log_manager')
    def test_get_log_files_returns_500_on_exception(self, mock_lm):
        mock_lm.get_all_log_file_infos.side_effect = Exception('filesystem error')
        r = self.client.get('/api/logs/files')
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))


class TestLogVerbosity(unittest.TestCase):
    """GET /api/logs/verbosity and PUT /api/logs/verbosity"""

    def setUp(self):
        app.config['TESTING'] = True
        self.client = app.test_client()

    @patch('app.config_manager')
    def test_get_verbosity_returns_200_with_python_and_containers(self, mock_cm):
        mock_cm.get_logging_config.return_value = {
            'python': {'root': 'INFO', 'services': {'email': 'DEBUG', 'wireguard': 'WARNING'}},
            'containers': {'caddy': 'INFO', 'coredns': 'DEBUG'},
        }
        r = self.client.get('/api/logs/verbosity')
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertEqual(data['python']['services']['email'], 'DEBUG')
        self.assertEqual(data['containers']['coredns'], 'DEBUG')

    @patch('app.config_manager')
    def test_get_verbosity_returns_500_on_exception(self, mock_cm):
        mock_cm.get_logging_config.side_effect = Exception('config missing')
        r = self.client.get('/api/logs/verbosity')
        self.assertEqual(r.status_code, 500)
        self.assertIn('error', json.loads(r.data))

    @patch('app.apply_root_log_level')
    @patch('app.log_manager')
    @patch('app.config_manager')
    def test_put_verbosity_python_applies_hot(self, mock_cm, mock_lm, mock_apply):
        mock_cm.get_logging_config.return_value = {
            'python': {'root': 'DEBUG', 'services': {'network': 'DEBUG'}},
            'containers': {},
        }
        with patch('app.auth_manager', MagicMock(spec=object)):
            r = self.client.put(
                '/api/logs/verbosity',
                data=json.dumps({'python': {'root': 'DEBUG', 'services': {'network': 'DEBUG'}}}),
                content_type='application/json',
            )
        self.assertEqual(r.status_code, 200)
        mock_cm.set_python_log_level.assert_any_call('network', 'DEBUG')
        mock_cm.set_python_log_level.assert_any_call('root', 'DEBUG')
        mock_lm.set_service_level.assert_called_with('network', 'DEBUG')
        mock_apply.assert_called_with('DEBUG')

    @patch('app.firewall_manager')
    @patch('app.config_manager')
    def test_put_verbosity_coredns_applies_hot(self, mock_cm, mock_fw):
        mock_cm.get_logging_config.return_value = {'python': {}, 'containers': {'coredns': 'DEBUG'}}
        mock_cm.get_internal_domain.return_value = 'cell'
        with patch('app.auth_manager', MagicMock(spec=object)), \
             patch('app.peer_registry', MagicMock(list_peers=lambda: [])), \
             patch('app.cell_link_manager', MagicMock(list_connections=lambda: None)):
            r = self.client.put(
                '/api/logs/verbosity',
                data=json.dumps({'containers': {'coredns': 'DEBUG'}}),
                content_type='application/json',
            )
        self.assertEqual(r.status_code, 200)
        data = json.loads(r.data)
        self.assertEqual(data['applied']['coredns'], 'hot')
        mock_fw.generate_corefile.assert_called_once()
        mock_fw.reload_coredns.assert_called_once()

    @patch('app.config_manager')
    def test_put_verbosity_wireguard_returns_pending_restart(self, mock_cm):
        mock_cm.get_logging_config.return_value = {'python': {}, 'containers': {'wireguard': 'DEBUG'}}
        with patch('app.auth_manager', MagicMock(spec=object)):
            r = self.client.put(
                '/api/logs/verbosity',
                data=json.dumps({'containers': {'wireguard': 'DEBUG'}}),
                content_type='application/json',
            )
        self.assertEqual(r.status_code, 200)
        self.assertEqual(json.loads(r.data)['applied']['wireguard'], 'pending_restart')

    @patch('app.config_manager')
    def test_put_verbosity_invalid_level_returns_400(self, mock_cm):
        mock_cm.set_python_log_level.side_effect = ValueError('Invalid log level')
        with patch('app.auth_manager', MagicMock(spec=object)):
            r = self.client.put(
                '/api/logs/verbosity',
                data=json.dumps({'python': {'services': {'network': 'LOUD'}}}),
                content_type='application/json',
            )
        self.assertEqual(r.status_code, 400)
        self.assertIn('error', json.loads(r.data))


if __name__ == '__main__':
    unittest.main()