Added functionality to run java E2E framework from application on current project/module

Author: darginmathi

core/test_runner.py

@@ -0,0 +1,148 @@
+from PyQt6.QtCore import QObject, QProcess, pyqtSignal, QProcessEnvironment, QTimer
+from models.run_config import RunConfig
+import os
+
+# MAVEN_EXECUTABLE_PATH = "C:\\Users\\meetd\\Downloads\\apache-maven-3.9.10-bin\\apache-maven-3.9.10\\bin\\mvn.cmd"
+MAVEN_EXECUTABLE_PATH = "mvn"
+
+class TestRunner(QObject):
+    process_started = pyqtSignal()
+    process_finished = pyqtSignal(int)
+    output_received = pyqtSignal(str)
+    error_received = pyqtSignal(str)
+
+    def __init__(self, e2e_dir: str):
+        super().__init__()
+        self.e2e_dir = e2e_dir
+        self.process = None
+        self.is_running = False
+        self._force_kill_timer = QTimer()
+        self._force_kill_timer.setSingleShot(True)
+        self._force_kill_timer.timeout.connect(self._force_kill_process)
+
+    def run_test(self, config: RunConfig):
+        if self.is_running:
+            self.output_received.emit("Test already running! Stop it first.")
+            return
+
+        # Verify directory and pom.xml
+        if not os.path.exists(self.e2e_dir):
+            self.error_received.emit(f"E2E directory does not exist: {self.e2e_dir}")
+            return
+
+        pom_file = os.path.join(self.e2e_dir, "pom.xml")
+        if not os.path.exists(pom_file):
+            self.error_received.emit(f"pom.xml not found in E2E directory: {self.e2e_dir}")
+            return
+
+        args = self._build_command_args(config)
+
+        self.process = QProcess()
+        self.process.setWorkingDirectory(self.e2e_dir)
+
+        # Use system environment as-is (your PATH already has everything needed)
+        env = QProcessEnvironment.systemEnvironment()
+
+        # Just set JAVA_HOME since it's missing
+        if not env.contains("JAVA_HOME"):
+            env.insert("JAVA_HOME", r"C:\Program Files\Java\jdk-21")
+
+        self.process.setProcessEnvironment(env)
+
+        self.process.readyReadStandardOutput.connect(self._on_stdout)
+        self.process.readyReadStandardError.connect(self._on_stderr)
+        self.process.finished.connect(self._on_finished)
+        self.process.errorOccurred.connect(self._on_error)
+
+        self.is_running = True
+        self.process_started.emit()
+        self.output_received.emit(f"Starting test: {config.project_name}/{config.module_name}")
+
+        # Use mvn.cmd explicitly
+        self.process.start("mvn.cmd", args)
+
+    def _build_command_args(self, config: RunConfig) -> list:
+        exec_args = f"{config.project_name} {config.base_url} {config.browser} {config.video_option} {config.module_name} {config.wait_time}"
+
+        return [
+            "clean",
+            "compile",
+            "exec:java",
+            f"-Dexec.mainClass=com.startAuto.StartAuto",
+            f"-Dexec.args={exec_args}"
+        ]
+
+    def stop_test(self):
+        if not self.is_running or not self.process:
+            return
+
+        self.output_received.emit("Stopping test execution...")
+        self.process.terminate()
+
+        self._force_kill_timer.start(3000)
+
+    def _force_kill_process(self):
+        if self.is_running and self.process and self.process.state() == QProcess.ProcessState.Running:
+            self.process.kill()
+            self.output_received.emit("Force killed process")
+            self.is_running = False
+            self.output_received.emit("Test stopped")
+
+    def _on_stdout(self):
+        if self.process:
+            data = self.process.readAllStandardOutput().data().decode()
+            self.output_received.emit(data)
+
+    def _on_stderr(self):
+        if self.process:
+            data = self.process.readAllStandardError().data().decode()
+            self.error_received.emit(f"❌ {data}")
+
+    def _on_finished(self, exit_code):
+        self.is_running = False
+        self._force_kill_timer.stop()
+        if exit_code == 0:
+            self.output_received.emit("✅ Test completed successfully")
+        else:
+            self.output_received.emit(f"❌ Test failed with exit code: {exit_code}")
+        self.process_finished.emit(exit_code)
+
+    def is_test_running(self):
+        return self.is_running
+
+    def cleanup(self):
+        if self.process:
+            self._force_kill_timer.stop()
+
+            if self.process.state() == QProcess.ProcessState.Running:
+                self.process.kill()
+                self.process.waitForFinished(100)
+
+            try:
+                self.process.readyReadStandardOutput.disconnect()
+                self.process.readyReadStandardError.disconnect()
+                self.process.finished.disconnect()
+                self.process.errorOccurred.disconnect()
+            except:
+                pass
+
+            self.process = None
+
+        self.is_running = False
+
+    def _on_error(self, error: QProcess.ProcessError):
+        error_messages = {
+            QProcess.ProcessError.FailedToStart: "❌ Failed to start the process. Check if Maven and Java are properly configured.",
+            QProcess.ProcessError.Crashed: "The process crashed.",
+            QProcess.ProcessError.Timedout: "The process timed out.",
+            QProcess.ProcessError.ReadError: "An error occurred while reading from the process.",
+            QProcess.ProcessError.WriteError: "An error occurred while writing to the process.",
+            QProcess.ProcessError.UnknownError: "An unknown error occurred."
+            }
+        self.error_received.emit(f"Process Error: {error_messages.get(error, 'An unknown error occurred.')}")
+
+        if error == QProcess.ProcessError.FailedToStart:
+            self.error_received.emit("Please ensure:")
+            self.error_received.emit("1. Java JDK is installed and JAVA_HOME is set")
+            self.error_received.emit("2. Maven is installed and in PATH")
+            self.error_received.emit("4. The E2E directory contains a valid Maven project")

models/run_config.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from PyQt6.QtCore import QSettings
+
+@dataclass
+class RunConfig:
+    project_name: str = ""
+    module_name: str = ""
+    base_url: str = ""
+    browser: str = "ChromeHL"
+    video_option: str = "NONE"
+    wait_time: int = 30
+
+    def save_to_settings(self):
+        settings = QSettings("TestEditor", "RunConfig")
+        settings.setValue("browser", self.browser)
+        settings.setValue("video_option", self.video_option)
+        settings.setValue("wait_time", self.wait_time)
+
+    def load_from_settings(self):
+        settings = QSettings("TestEditor", "RunConfig")
+        self.browser = settings.value("browser", "ChromeHL")
+        self.video_option = settings.value("video_option", "NONE")
+        self.wait_time = settings.value("wait_time", 30, type=int)
+
+default_config = RunConfig()
+default_config.load_from_settings()
+
+
+def get_base_url(project_name: str) -> str:
+    return PROJECT_URLS.get(project_name, "")
+
+PROJECT_URLS = {
+    "qaoptimus": "https://qaoptimus.synoption.com/#/auth/login",
+    "uatoptimus": "https://uatoptimus.synoption.com/#/auth/login",
+    "qatitan": "https://qatitan.synoption.com/#/auth/login",
+    "uattitan": "https://uattitan.synoption.com/#/auth/login",
+    "uatmaqa": "https://uatmaqa.synoption.com/#/auth/login",
+    "qaocbctitan": "https://qaocbctitan.synoption.com/#/auth/login",
+    "uatocbctitan": "https://uatocbctitan.synoption.com/#/auth/login",
+}

ui/file_ui.py

@@ -1,5 +1,6 @@
 import os
 import re
+from pathlib import Path
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QListWidget, QLabel,
     QPushButton, QListWidgetItem, QFileDialog, QMessageBox,
@@ -12,6 +13,7 @@ def __init__(self,main = None, mode="open"):
         super().__init__(main)
         self.mode = mode
         self.main = main
+        self.e2e_dir = None
         self.data_directory = None
         self.selected_project = None
         self.selected_scenario_path = None
@@ -36,13 +38,13 @@ def _setup_ui(self):
 
     def _create_directory_layout(self):
         dir_layout = QHBoxLayout()
-        dir_layout.addWidget(QLabel("Data Directory: "))
+        dir_layout.addWidget(QLabel("E2E Directory: "))
 
         self.dir_label = QLabel("Not Selected")
         dir_layout.addWidget(self.dir_label)
 
         self.select_dir = QPushButton("Select Dir")
-        self.select_dir.clicked.connect(self._select_data_directory)
+        self.select_dir.clicked.connect(self._select_e2e_directory)
         dir_layout.addWidget(self.select_dir)
 
         return dir_layout
@@ -108,27 +110,49 @@ def _create_buttons_section(self):
 
     def _load_last_directory(self):
         settings = QSettings("TestEditor", "Settings")
-        last_dir = settings.value("last_directory", "")
+        e2e_dir = settings.value("e2e_dir", "")
 
-        if last_dir and os.path.exists(last_dir):
-            self.data_directory = last_dir
-            self.dir_label.setText(last_dir)
+        if e2e_dir and os.path.exists(e2e_dir):
+            self.e2e_dir = e2e_dir
+            self.data_directory = os.path.join(e2e_dir, "data")
+            self.dir_label.setText(e2e_dir)
             self._populate_projects()
             self._load_last_project()
 
     def _save_last_directory(self):
         if self.data_directory:
             settings = QSettings("TestEditor", "Settings")
-            settings.setValue("last_directory", self.data_directory)
+            settings.setValue("e2e_dir", self.e2e_dir)
 
-    def _select_data_directory(self):
+    def _select_e2e_directory(self):
         directory = QFileDialog.getExistingDirectory(self, "Select Directory")
         if directory:
-            self.data_directory = directory
-            self.dir_label.setText(directory)
-            self._save_last_directory()
-            self._populate_projects()
-            self._load_last_project()
+            e2e_dir = directory
+            data_dir = os.path.join(directory, "data")
+
+            if self._validate_directory(e2e_dir, data_dir):
+                self.e2e_dir = directory
+                self.data_directory = data_dir
+
+                self.dir_label.setText(self.data_directory)
+                self._save_last_directory()
+                self._populate_projects()
+                self._load_last_project()
+            else:
+                QMessageBox.warning(self, "Invalid Directory",
+                "Selected directory should be the E2E application root with 'data/' subdirectory")
+
+    def _validate_directory(self, e2e_dir, data_dir):
+        app_path = Path(e2e_dir)
+        data_path = Path(data_dir)
+
+        has_pom = (app_path / "pom.xml").exists()
+        has_src = (app_path / "src").exists()
+
+        has_test_suites = (data_path / "testSuites").exists()
+        has_obj_repos = (data_path / "objectRepositories").exists()
+
+        return has_pom and has_src and has_test_suites and has_obj_repos
 
     def _load_last_project(self):
         if self.mode != "open":

ui/menu.py

@@ -1,5 +1,8 @@
 from PyQt6.QtGui import QAction, QKeySequence
-from PyQt6.QtWidgets import QMenuBar, QMessageBox
+from PyQt6.QtWidgets import QMenuBar, QMessageBox, QToolBar, QToolButton
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QStyle
+from PyQt6.QtCore import QSize
 from core.commands import COMMANDS
 from models.test_scenario import TestScenarioModel
 from typing import TYPE_CHECKING
@@ -14,6 +17,7 @@ def __init__(self, main: "MainWindow") -> None:
         self.main = main
         self.file_ops = main.file_ops
         self.create_menu_bar()
+        self.create_corner_run_toolbar()
 
     def create_menu_bar(self) -> None:
 
@@ -165,3 +169,45 @@ def apply_fixed_widths(self) -> None:
                 message_type="warning",
                 timeout=5000
             )
+
+    def create_corner_run_toolbar(self):
+        """Super compact icons-only in corner"""
+        run_toolbar = QToolBar("Run", self)
+        run_toolbar.setAccessibleName("corner-toolbar")
+        run_toolbar.setMovable(False)
+        run_toolbar.setFloatable(False)
+        run_toolbar.setIconSize(QSize(14, 14))
+
+        # Add buttons (same as above)
+        self.run_button = QToolButton()
+        self.run_button.setText("▶")
+        self.run_button.setToolTip("Run Current Module (Ctrl+R)")
+        self.run_button.clicked.connect(self.run_current_module)
+        self.run_button.setObjectName("RunButton")
+        run_toolbar.addWidget(self.run_button)
+
+        self.stop_button = QToolButton()
+        self.stop_button.setText("■")
+        self.stop_button.setToolTip("Stop Execution (Ctrl+Shift+R)")
+        self.stop_button.clicked.connect(self.stop_test)
+        self.stop_button.setObjectName("StopButton")
+        self.stop_button.setEnabled(False)
+        run_toolbar.addWidget(self.stop_button)
+
+        self.config_button = QToolButton()
+        self.config_button.setText("⚙")
+        self.config_button.setToolTip("Run Configuration")
+        self.config_button.clicked.connect(self.show_run_config)
+        self.config_button.setObjectName("ConfigButton")
+        run_toolbar.addWidget(self.config_button)
+
+        self.main.menuBar().setCornerWidget(run_toolbar, Qt.Corner.TopRightCorner)
+
+    def run_current_module(self):
+        self.main.run_current_module()
+
+    def stop_test(self):
+        self.main.stop_test()
+
+    def show_run_config(self):
+        self.main.show_run_config()

ui/output_dock.py

@@ -0,0 +1,49 @@
+from PyQt6.QtWidgets import (QDockWidget, QTextEdit, QVBoxLayout, QWidget,
+                             QHBoxLayout, QPushButton, QLabel)
+from PyQt6.QtCore import Qt, pyqtSignal
+
+class ConsoleDock(QDockWidget):
+    clear_requested = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super().__init__("Console", parent)
+        self.setup_ui()
+
+    def setup_ui(self):
+        widget = QWidget()
+        layout = QVBoxLayout(widget)
+
+        header_layout = QHBoxLayout()
+
+        self.status_label = QLabel("Ready")
+        header_layout.addWidget(self.status_label)
+
+        header_layout.addStretch()
+
+        self.clear_btn = QPushButton("Clear")
+        self.clear_btn.clicked.connect(self.clear_requested.emit)
+        self.clear_btn.setMaximumWidth(60)
+        header_layout.addWidget(self.clear_btn)
+
+        layout.addLayout(header_layout)
+
+        self.output_text = QTextEdit()
+        self.output_text.setReadOnly(True)
+        self.output_text.setPlaceholderText("Test output will appear here...")
+
+        layout.addWidget(self.output_text)
+        self.setWidget(widget)
+
+    def append_output(self, text):
+        self.output_text.append(text)
+        cursor = self.output_text.textCursor()
+        cursor.movePosition(cursor.MoveOperation.End)
+        self.output_text.setTextCursor(cursor)
+
+    def clear_output(self):
+        self.output_text.clear()
+        self.status_label.setText("Ready")
+
+    def set_status(self, status, is_error=False):
+        color = "red" if is_error else "green"
+        self.status_label.setText(f"<span style='color: {color};'>{status}</span>")