ci-testing

scripts/ci-server.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""
+CI Server Script - Запускает серверы для тестирования в неблокирующем режиме
+"""
+
+import os
+import sys
+import time
+import signal
+import subprocess
+import threading
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+# Добавляем корневую папку в путь
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+# Создаем собственный логгер без дублирования
+def create_ci_logger():
+    """Создает логгер для CI без дублирования"""
+    logger = logging.getLogger("ci-server")
+    logger.setLevel(logging.INFO)
+    
+    # Убираем существующие обработчики
+    logger.handlers.clear()
+    
+    # Создаем форматтер
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    
+    # Создаем обработчик
+    handler = logging.StreamHandler()
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    
+    # Отключаем пропагацию к root logger
+    logger.propagate = False
+    
+    return logger
+
+logger = create_ci_logger()
+
+
+class CIServerManager:
+    """Менеджер CI серверов"""
+    
+    def __init__(self):
+        self.backend_process: Optional[subprocess.Popen] = None
+        self.frontend_process: Optional[subprocess.Popen] = None
+        self.backend_pid_file = Path("backend.pid")
+        self.frontend_pid_file = Path("frontend.pid")
+        
+        # Настройки по умолчанию
+        self.backend_host = os.getenv("BACKEND_HOST", "0.0.0.0")
+        self.backend_port = int(os.getenv("BACKEND_PORT", "8000"))
+        self.frontend_port = int(os.getenv("FRONTEND_PORT", "3000"))
+        
+        # Флаги состояния
+        self.backend_ready = False
+        self.frontend_ready = False
+        
+        # Обработчики сигналов для корректного завершения
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+    
+    def _signal_handler(self, signum: int, frame: Any) -> None:
+        """Обработчик сигналов для корректного завершения"""
+        logger.info(f"Получен сигнал {signum}, завершаем работу...")
+        self.cleanup()
+        sys.exit(0)
+    
+    def start_backend_server(self) -> bool:
+        """Запускает backend сервер"""
+        try:
+            logger.info(f"🚀 Запускаем backend сервер на {self.backend_host}:{self.backend_port}")
+            
+            # Запускаем сервер в фоне
+            self.backend_process = subprocess.Popen(
+                [
+                    sys.executable, "dev.py",
+                    "--host", self.backend_host,
+                    "--port", str(self.backend_port)
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            # Сохраняем PID
+            self.backend_pid_file.write_text(str(self.backend_process.pid))
+            logger.info(f"✅ Backend сервер запущен с PID: {self.backend_process.pid}")
+            
+            # Запускаем мониторинг в отдельном потоке
+            threading.Thread(
+                target=self._monitor_backend,
+                daemon=True
+            ).start()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка запуска backend сервера: {e}")
+            return False
+    
+    def start_frontend_server(self) -> bool:
+        """Запускает frontend сервер"""
+        try:
+            logger.info(f"🚀 Запускаем frontend сервер на порту {self.frontend_port}")
+            
+            # Переходим в папку panel
+            panel_dir = Path("panel")
+            if not panel_dir.exists():
+                logger.error("❌ Папка panel не найдена")
+                return False
+            
+            # Запускаем npm run dev в фоне
+            self.frontend_process = subprocess.Popen(
+                ["npm", "run", "dev"],
+                cwd=panel_dir,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            # Сохраняем PID
+            self.frontend_pid_file.write_text(str(self.frontend_process.pid))
+            logger.info(f"✅ Frontend сервер запущен с PID: {self.frontend_process.pid}")
+            
+            # Запускаем мониторинг в отдельном потоке
+            threading.Thread(
+                target=self._monitor_frontend,
+                daemon=True
+            ).start()
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка запуска frontend сервера: {e}")
+            return False
+    
+    def _monitor_backend(self) -> None:
+        """Мониторит backend сервер"""
+        try:
+            while self.backend_process and self.backend_process.poll() is None:
+                time.sleep(1)
+                
+                # Проверяем доступность сервера
+                if not self.backend_ready:
+                    try:
+                        import requests
+                        response = requests.get(
+                            f"http://{self.backend_host}:{self.backend_port}/",
+                            timeout=5
+                        )
+                        if response.status_code == 200:
+                            self.backend_ready = True
+                            logger.info("✅ Backend сервер готов к работе!")
+                        else:
+                            logger.debug(f"Backend отвечает с кодом: {response.status_code}")
+                    except Exception as e:
+                        logger.debug(f"Backend еще не готов: {e}")
+                        
+        except Exception as e:
+            logger.error(f"❌ Ошибка мониторинга backend: {e}")
+    
+    def _monitor_frontend(self) -> None:
+        """Мониторит frontend сервер"""
+        try:
+            while self.frontend_process and self.frontend_process.poll() is None:
+                time.sleep(1)
+                
+                # Проверяем доступность сервера
+                if not self.frontend_ready:
+                    try:
+                        import requests
+                        response = requests.get(
+                            f"http://localhost:{self.frontend_port}/",
+                            timeout=5
+                        )
+                        if response.status_code == 200:
+                            self.frontend_ready = True
+                            logger.info("✅ Frontend сервер готов к работе!")
+                        else:
+                            logger.debug(f"Frontend отвечает с кодом: {response.status_code}")
+                    except Exception as e:
+                        logger.debug(f"Frontend еще не готов: {e}")
+                        
+        except Exception as e:
+            logger.error(f"❌ Ошибка мониторинга frontend: {e}")
+    
+    def wait_for_servers(self, timeout: int = 120) -> bool:
+        """Ждет пока серверы будут готовы"""
+        logger.info(f"⏳ Ждем готовности серверов (таймаут: {timeout}с)...")
+        
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            logger.debug(f"Backend готов: {self.backend_ready}, Frontend готов: {self.frontend_ready}")
+            
+            if self.backend_ready and self.frontend_ready:
+                logger.info("🎉 Все серверы готовы к работе!")
+                return True
+            
+            time.sleep(2)
+        
+        logger.error("⏰ Таймаут ожидания готовности серверов")
+        logger.error(f"Backend готов: {self.backend_ready}, Frontend готов: {self.frontend_ready}")
+        return False
+    
+    def cleanup(self) -> None:
+        """Очищает ресурсы и завершает процессы"""
+        logger.info("🧹 Очищаем ресурсы...")
+        
+        # Завершаем процессы
+        if self.backend_process:
+            try:
+                self.backend_process.terminate()
+                self.backend_process.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                self.backend_process.kill()
+            except Exception as e:
+                logger.error(f"Ошибка завершения backend: {e}")
+        
+        if self.frontend_process:
+            try:
+                self.frontend_process.terminate()
+                self.frontend_process.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                self.frontend_process.kill()
+            except Exception as e:
+                logger.error(f"Ошибка завершения frontend: {e}")
+        
+        # Удаляем PID файлы
+        for pid_file in [self.backend_pid_file, self.frontend_pid_file]:
+            if pid_file.exists():
+                try:
+                    pid_file.unlink()
+                except Exception as e:
+                    logger.error(f"Ошибка удаления {pid_file}: {e}")
+        
+        # Убиваем все связанные процессы
+        try:
+            subprocess.run(["pkill", "-f", "python dev.py"], check=False)
+            subprocess.run(["pkill", "-f", "npm run dev"], check=False)
+            subprocess.run(["pkill", "-f", "vite"], check=False)
+        except Exception as e:
+            logger.error(f"Ошибка принудительного завершения: {e}")
+        
+        logger.info("✅ Очистка завершена")
+
+
+def main():
+    """Основная функция"""
+    logger.info("🚀 Запуск CI Server Manager")
+    
+    # Создаем менеджер
+    manager = CIServerManager()
+    
+    try:
+        # Запускаем серверы
+        if not manager.start_backend_server():
+            logger.error("❌ Не удалось запустить backend сервер")
+            return 1
+        
+        if not manager.start_frontend_server():
+            logger.error("❌ Не удалось запустить frontend сервер")
+            return 1
+        
+        # Ждем готовности
+        if not manager.wait_for_servers():
+            logger.error("❌ Серверы не готовы в течение таймаута")
+            return 1
+        
+        logger.info("🎯 Серверы запущены и готовы к тестированию")
+        
+        # В CI режиме запускаем тесты автоматически
+        ci_mode = os.getenv("CI_MODE", "false").lower()
+        logger.info(f"🔧 Проверяем CI режим: CI_MODE={ci_mode}")
+        
+        if ci_mode in ["true", "1", "yes"]:
+            logger.info("🔧 CI режим: запускаем тесты автоматически...")
+            return run_tests_in_ci()
+        else:
+            logger.info("💡 Локальный режим: для запуска тестов нажмите Ctrl+C")
+            
+            # Держим скрипт запущенным
+            try:
+                while True:
+                    time.sleep(1)
+                    # Проверяем что процессы еще живы
+                    if (manager.backend_process and manager.backend_process.poll() is not None):
+                        logger.error("❌ Backend сервер завершился неожиданно")
+                        break
+                    if (manager.frontend_process and manager.frontend_process.poll() is not None):
+                        logger.error("❌ Frontend сервер завершился неожиданно")
+                        break
+            except KeyboardInterrupt:
+                logger.info("👋 Получен сигнал прерывания")
+        
+        return 0
+        
+    except Exception as e:
+        logger.error(f"❌ Критическая ошибка: {e}")
+        return 1
+        
+    finally:
+        manager.cleanup()
+
+
+def run_tests_in_ci() -> int:
+    """Запускает тесты в CI режиме"""
+    try:
+        logger.info("🧪 Запускаем unit тесты...")
+        result = subprocess.run([
+            "uv", "run", "pytest", "tests/", "-m", "not e2e", "-v", "--tb=short"
+        ], capture_output=False, text=True)  # Убираем capture_output=False
+        
+        if result.returncode != 0:
+            logger.error(f"❌ Unit тесты провалились с кодом: {result.returncode}")
+            return result.returncode
+        
+        logger.info("✅ Unit тесты прошли успешно!")
+        
+        logger.info("🧪 Запускаем integration тесты...")
+        result = subprocess.run([
+            "uv", "run", "pytest", "tests/", "-m", "integration", "-v", "--tb=short"
+        ], capture_output=False, text=True)  # Убираем capture_output=False
+        
+        if result.returncode != 0:
+            logger.error(f"❌ Integration тесты провалились с кодом: {result.returncode}")
+            return result.returncode
+        
+        logger.info("✅ Integration тесты прошли успешно!")
+        
+        logger.info("🧪 Запускаем E2E тесты...")
+        result = subprocess.run([
+            "uv", "run", "pytest", "tests/", "-m", "e2e", "-v", "--tb=short", "--timeout=300"
+        ], capture_output=False, text=True)  # Убираем capture_output=False
+        
+        if result.returncode != 0:
+            logger.error(f"❌ E2E тесты провалились с кодом: {result.returncode}")
+            return result.returncode
+        
+        logger.info("✅ E2E тесты прошли успешно!")
+        
+        logger.info("🎉 Все тесты прошли успешно!")
+        return 0
+        
+    except Exception as e:
+        logger.error(f"❌ Ошибка при запуске тестов: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())