pic/test_app_endpoints.py

#!/usr/bin/env python3
"""
Comprehensive tests for Flask app endpoints
"""

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

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

class TestFlaskAppEndpoints(unittest.TestCase):
    def setUp(self):
        """Set up test environment"""
        # Create temporary directories
        self.test_dir = tempfile.mkdtemp()
        self.data_dir = os.path.join(self.test_dir, 'data')
        self.config_dir = os.path.join(self.test_dir, 'config')
        os.makedirs(self.data_dir, exist_ok=True)
        os.makedirs(self.config_dir, exist_ok=True)
        
        # Set environment variables
        os.environ['TESTING'] = 'true'
        os.environ['LOG_LEVEL'] = 'ERROR'
        
        # Import and create app
        from app import app
        self.app = app
        self.client = app.test_client()
        
        # Mock external dependencies
        self.patchers = []
        
        # Mock subprocess.run
        subprocess_patcher = patch('subprocess.run')
        self.mock_subprocess = subprocess_patcher.start()
        self.mock_subprocess.return_value.returncode = 0
        self.mock_subprocess.return_value.stdout = b"test output"
        self.patchers.append(subprocess_patcher)
        
        # Mock docker
        docker_patcher = patch('docker.from_env')
        self.mock_docker = docker_patcher.start()
        self.mock_docker_client = MagicMock()
        self.mock_docker.return_value = self.mock_docker_client
        self.patchers.append(docker_patcher)
        
        # Mock file operations
        file_patcher = patch('builtins.open', create=True)
        self.mock_file = file_patcher.start()
        self.mock_file.return_value.__enter__.return_value.read.return_value = '{}'
        self.patchers.append(file_patcher)
        
    def tearDown(self):
        """Clean up test environment"""
        shutil.rmtree(self.test_dir)
        for patcher in self.patchers:
            patcher.stop()
    
    def test_health_endpoint(self):
        """Test /health endpoint"""
        response = self.client.get('/health')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_status_endpoint(self):
        """Test /api/status endpoint"""
        response = self.client.get('/api/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_config_get_endpoint(self):
        """Test GET /api/config endpoint"""
        response = self.client.get('/api/config')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, dict)
    
    def test_api_config_put_endpoint(self):
        """Test PUT /api/config endpoint"""
        test_config = {'test': 'value'}
        response = self.client.put('/api/config', 
                                 data=json.dumps(test_config),
                                 content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_config_backup_endpoint(self):
        """Test POST /api/config/backup endpoint"""
        response = self.client.post('/api/config/backup')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('backup_id', data)
    
    def test_api_config_backups_endpoint(self):
        """Test GET /api/config/backups endpoint"""
        response = self.client.get('/api/config/backups')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_config_restore_endpoint(self):
        """Test POST /api/config/restore/<backup_id> endpoint"""
        response = self.client.post('/api/config/restore/test_backup')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_config_export_endpoint(self):
        """Test GET /api/config/export endpoint"""
        response = self.client.get('/api/config/export')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, dict)
    
    def test_api_config_import_endpoint(self):
        """Test POST /api/config/import endpoint"""
        test_config = {'test': 'value'}
        response = self.client.post('/api/config/import',
                                  data=json.dumps(test_config),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_services_bus_status_endpoint(self):
        """Test GET /api/services/bus/status endpoint"""
        response = self.client.get('/api/services/bus/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('services', data)
    
    def test_api_services_bus_events_endpoint(self):
        """Test GET /api/services/bus/events endpoint"""
        response = self.client.get('/api/services/bus/events')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_services_bus_start_endpoint(self):
        """Test POST /api/services/bus/services/<service_name>/start endpoint"""
        response = self.client.post('/api/services/bus/services/test/start')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_services_bus_stop_endpoint(self):
        """Test POST /api/services/bus/services/<service_name>/stop endpoint"""
        response = self.client.post('/api/services/bus/services/test/stop')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_services_bus_restart_endpoint(self):
        """Test POST /api/services/bus/services/<service_name>/restart endpoint"""
        response = self.client.post('/api/services/bus/services/test/restart')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_logs_services_endpoint(self):
        """Test GET /api/logs/services/<service> endpoint"""
        response = self.client.get('/api/logs/services/test')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_logs_search_endpoint(self):
        """Test POST /api/logs/search endpoint"""
        search_data = {'query': 'test', 'level': 'INFO'}
        response = self.client.post('/api/logs/search',
                                  data=json.dumps(search_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_logs_export_endpoint(self):
        """Test POST /api/logs/export endpoint"""
        export_data = {'format': 'json', 'filters': {}}
        response = self.client.post('/api/logs/export',
                                  data=json.dumps(export_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('export_path', data)
    
    def test_api_logs_statistics_endpoint(self):
        """Test GET /api/logs/statistics endpoint"""
        response = self.client.get('/api/logs/statistics')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('total_entries', data)
    
    def test_api_logs_rotate_endpoint(self):
        """Test POST /api/logs/rotate endpoint"""
        response = self.client.post('/api/logs/rotate')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_dns_records_endpoints(self):
        """Test DNS records endpoints"""
        # GET
        response = self.client.get('/api/dns/records')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST
        record_data = {'name': 'test.example.com', 'type': 'A', 'value': '192.168.1.1'}
        response = self.client.post('/api/dns/records',
                                  data=json.dumps(record_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE
        response = self.client.delete('/api/dns/records',
                                    data=json.dumps(record_data),
                                    content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_dhcp_endpoints(self):
        """Test DHCP endpoints"""
        # GET leases
        response = self.client.get('/api/dhcp/leases')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST reservation
        reservation_data = {'mac': '00:11:22:33:44:55', 'ip': '192.168.1.100'}
        response = self.client.post('/api/dhcp/reservations',
                                  data=json.dumps(reservation_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE reservation
        response = self.client.delete('/api/dhcp/reservations',
                                    data=json.dumps(reservation_data),
                                    content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_ntp_status_endpoint(self):
        """Test GET /api/ntp/status endpoint"""
        response = self.client.get('/api/ntp/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_network_info_endpoint(self):
        """Test GET /api/network/info endpoint"""
        response = self.client.get('/api/network/info')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('interfaces', data)
    
    def test_api_dns_status_endpoint(self):
        """Test GET /api/dns/status endpoint"""
        response = self.client.get('/api/dns/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_network_test_endpoint(self):
        """Test POST /api/network/test endpoint"""
        test_data = {'target': '8.8.8.8', 'type': 'ping'}
        response = self.client.post('/api/network/test',
                                  data=json.dumps(test_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_wireguard_endpoints(self):
        """Test WireGuard endpoints"""
        # GET keys
        response = self.client.get('/api/wireguard/keys')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('public_key', data)
        
        # POST generate peer keys
        response = self.client.post('/api/wireguard/keys/peer')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('public_key', data)
        
        # GET config
        response = self.client.get('/api/wireguard/config')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('config', data)
        
        # GET peers
        response = self.client.get('/api/wireguard/peers')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST add peer
        peer_data = {'peer': 'test_peer', 'ip': '10.0.0.1', 'public_key': 'test_key'}
        response = self.client.post('/api/wireguard/peers',
                                  data=json.dumps(peer_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE remove peer
        response = self.client.delete('/api/wireguard/peers',
                                    data=json.dumps({'peer': 'test_peer'}),
                                    content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # GET status
        response = self.client.get('/api/wireguard/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_peers_endpoints(self):
        """Test peers endpoints"""
        # GET peers
        response = self.client.get('/api/peers')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST add peer
        peer_data = {'peer': 'test_peer', 'ip': '10.0.0.1'}
        response = self.client.post('/api/peers',
                                  data=json.dumps(peer_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE remove peer
        response = self.client.delete('/api/peers/test_peer')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
    
    def test_api_email_endpoints(self):
        """Test email endpoints"""
        # GET users
        response = self.client.get('/api/email/users')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST create user
        user_data = {'username': 'test_user', 'email': 'test@example.com'}
        response = self.client.post('/api/email/users',
                                  data=json.dumps(user_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE user
        response = self.client.delete('/api/email/users/test_user')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # GET status
        response = self.client.get('/api/email/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_calendar_endpoints(self):
        """Test calendar endpoints"""
        # GET users
        response = self.client.get('/api/calendar/users')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST create user
        user_data = {'username': 'test_user', 'email': 'test@example.com'}
        response = self.client.post('/api/calendar/users',
                                  data=json.dumps(user_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE user
        response = self.client.delete('/api/calendar/users/test_user')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # GET status
        response = self.client.get('/api/calendar/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_files_endpoints(self):
        """Test files endpoints"""
        # GET users
        response = self.client.get('/api/files/users')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST create user
        user_data = {'username': 'test_user'}
        response = self.client.post('/api/files/users',
                                  data=json.dumps(user_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # DELETE user
        response = self.client.delete('/api/files/users/test_user')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # GET status
        response = self.client.get('/api/files/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
    
    def test_api_routing_endpoints(self):
        """Test routing endpoints"""
        # GET status
        response = self.client.get('/api/routing/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
        
        # POST NAT rule
        nat_data = {'type': 'masquerade', 'interface': 'eth0'}
        response = self.client.post('/api/routing/nat',
                                  data=json.dumps(nat_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('rule_id', data)
        
        # GET NAT rules
        response = self.client.get('/api/routing/nat')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_vault_endpoints(self):
        """Test vault endpoints"""
        # GET status
        response = self.client.get('/api/vault/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('status', data)
        
        # GET certificates
        response = self.client.get('/api/vault/certificates')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST generate certificate
        cert_data = {'common_name': 'test.example.com'}
        response = self.client.post('/api/vault/certificates',
                                  data=json.dumps(cert_data),
                                  content_type='application/json')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('certificate', data)
        
        # GET CA certificate
        response = self.client.get('/api/vault/ca/certificate')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('certificate', data)
    
    def test_api_containers_endpoints(self):
        """Test containers endpoints"""
        # GET containers
        response = self.client.get('/api/containers')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
        
        # POST start container
        response = self.client.post('/api/containers/test/start')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # POST stop container
        response = self.client.post('/api/containers/test/stop')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('success', data)
        
        # GET container logs
        response = self.client.get('/api/containers/test/logs')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_services_status_endpoint(self):
        """Test GET /api/services/status endpoint"""
        response = self.client.get('/api/services/status')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('services', data)
    
    def test_api_services_connectivity_endpoint(self):
        """Test GET /api/services/connectivity endpoint"""
        response = self.client.get('/api/services/connectivity')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIn('results', data)
    
    def test_api_health_history_endpoint(self):
        """Test GET /api/health/history endpoint"""
        response = self.client.get('/api/health/history')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)
    
    def test_api_logs_endpoint(self):
        """Test GET /api/logs endpoint"""
        response = self.client.get('/api/logs')
        self.assertEqual(response.status_code, 200)
        data = json.loads(response.data)
        self.assertIsInstance(data, list)

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