init

test_app_endpoints.py

@@ -0,0 +1,559 @@
+#!/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()