QCLI Automation for hooks,usage,issue,tools,subscribe,model,compact,editor tests

Author: sayemaanjum0412

e2etests/src/lib.rs

@@ -138,12 +138,12 @@ pub mod q_chat_helper {
                     },
                     Ok(_) => {
                         // No more data, but wait a bit more in case there's more coming
-                        std::thread::sleep(Duration::from_millis(2000));
+                        std::thread::sleep(Duration::from_millis(2500));
                         if total_content.len() > 0 { break; }
                     },
                     Err(_) => break,
                 }
-                std::thread::sleep(Duration::from_millis(2000));
+                std::thread::sleep(Duration::from_millis(2500));
             }
 
             Ok(total_content)

e2etests/tests/test_compact_command.rs

@@ -1,23 +1,23 @@
-use q_cli_e2e_tests::q_chat_helper::QChatSession;
+use q_cli_e2e_tests::{get_chat_session, cleanup_if_last_test};
+use std::sync::atomic::{AtomicUsize, Ordering};
 
-#[test]
-#[cfg(feature = "compact")]
+static TEST_COUNT: AtomicUsize = AtomicUsize::new(0);
 
-fn test_all_compact_commands() -> Result<(), Box<dyn std::error::Error>> {
-    let mut chat = QChatSession::new()?;
-    println!(":white_check_mark: Q Chat session started");
-    
-    test_compact_command(&mut chat)?;
-    test_compact_help_command(&mut chat)?;
-    
-    chat.quit()?;
-    println!(":white_check_mark: All tests completed successfully");
-    Ok(())
-}
+// List of covered tests
+const TEST_NAMES: &[&str] = &[
+    "test_compact_command",
+    "test_compact_help_command",
+];
+const TOTAL_TESTS: usize = TEST_NAMES.len();
 
-fn test_compact_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+#[test]
+#[cfg(feature = "compact")]
+fn test_compact_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /compact command...");
 
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/compact")?;
 
     println!("📝 Compact response: {} bytes", response.len());
@@ -36,12 +36,23 @@ fn test_compact_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::erro
 
     println!("✅ All compact content verified!");
 
+    // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }
 
-fn test_compact_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+#[test]
+#[cfg(feature = "compact")]
+fn test_compact_help_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /compact --help command...");
 
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/compact --help")?;
 
     println!("📝 Compact help response: {} bytes", response.len());
@@ -94,5 +105,11 @@ fn test_compact_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std:
 
     println!("✅ All compact help content verified!");
 
+     // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }

e2etests/tests/test_editor_help_command.rs

@@ -1,23 +1,22 @@
-use q_cli_e2e_tests::q_chat_helper::QChatSession;
+use q_cli_e2e_tests::{get_chat_session, cleanup_if_last_test};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static TEST_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+// List of covered tests
+const TEST_NAMES: &[&str] = &[
+    "test_editor_help_command",
+    "test_help_editor_command",
+];
+const TOTAL_TESTS: usize = TEST_NAMES.len();
 
 #[test]
 #[cfg(feature = "editor")]
-fn test_all_editor_commands() -> Result<(), Box<dyn std::error::Error>> {
-    let mut chat = QChatSession::new()?;
-    println!(":white_check_mark: Q Chat session started");
-    
-    test_editor_help_command(&mut chat)?;
-    test_help_editor_command(&mut chat)?;
-    
-    chat.quit()?;
-    println!(":white_check_mark: All tests completed successfully");
-    Ok(())
-}
-fn test_editor_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+fn test_editor_help_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /editor --help command...");
 
-    let mut chat = QChatSession::new()?;
-    println!("✅ Q Chat session started");
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
 
     let response = chat.execute_command("/editor --help")?;
 
@@ -48,13 +47,24 @@ fn test_editor_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::
     println!("✅ Found help flags: -h, --help with Print help description");
 
     println!("✅ All editor help content verified!");
+    
+    // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
 
     Ok(())
 }
 
-fn test_help_editor_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+#[test]
+#[cfg(feature = "editor")]
+fn test_help_editor_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /help editor command...");
 
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/help editor")?;
 
     println!("📝 Help editor response: {} bytes", response.len());
@@ -80,6 +90,12 @@ fn test_help_editor_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::
     println!("✅ Found help flags: -h, --help with Print help description");
 
     println!("✅ All editor help content verified!");
- 
+    
+    // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }

e2etests/tests/test_hooks_command.rs

@@ -1,23 +1,23 @@
-use q_cli_e2e_tests::q_chat_helper::QChatSession;
+use q_cli_e2e_tests::{get_chat_session, cleanup_if_last_test};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static TEST_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+// List of covered tests
+const TEST_NAMES: &[&str] = &[
+    "test_hooks_command",
+    "test_hooks_help_command",
+];
+const TOTAL_TESTS: usize = TEST_NAMES.len();
 
 #[test]
 #[cfg(feature = "hooks")]
-fn test_all_hoooks_commands() -> Result<(), Box<dyn std::error::Error>> {
-    let mut chat = QChatSession::new()?;
-    println!(":white_check_mark: Q Chat session started");
-    
-    test_hooks_command(&mut chat)?;
-    test_hooks_help_command(&mut chat)?;
-    
-    chat.quit()?;
-    println!(":white_check_mark: All tests completed successfully");
-    Ok(())
-}
-
-fn test_hooks_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+fn test_hooks_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /hooks command...");
 
-    
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/hooks")?;
 
     println!("📝 Hooks command response: {} bytes", response.len());
@@ -36,12 +36,23 @@ fn test_hooks_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error:
 
     println!("✅ All hooks command functionality verified!");
 
+    // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }
 
-fn test_hooks_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+#[test]
+#[cfg(feature = "hooks")]
+fn test_hooks_help_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /hooks --help command...");
 
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/hooks --help")?;
 
     println!("📝 Hooks help response: {} bytes", response.len());
@@ -80,6 +91,11 @@ fn test_hooks_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::e
 
     println!("✅ All hooks help content verified!");
 
+     // Release the lock before cleanup
+    drop(chat);
 
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }

e2etests/tests/test_issue_command.rs

@@ -1,24 +1,24 @@
-use q_cli_e2e_tests::q_chat_helper::QChatSession;
+use q_cli_e2e_tests::{get_chat_session, cleanup_if_last_test};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static TEST_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+// List of covered tests
+const TEST_NAMES: &[&str] = &[
+    "test_issue_command",
+    "test_issue_force_command",
+    "test_issue_help_command",
+];
+const TOTAL_TESTS: usize = TEST_NAMES.len();
 
 #[test]
 #[cfg(feature = "issue_reporting")]
-fn test_all_issue_commands() -> Result<(), Box<dyn std::error::Error>> {
-    let mut chat = QChatSession::new()?;
-    println!(":white_check_mark: Q Chat session started");
-    
-    test_issue_command(&mut chat)?;
-    test_issue_force_command(&mut chat)?;
-    test_issue_help_command(&mut chat)?;
-    
-    chat.quit()?;
-    println!(":white_check_mark: All tests completed successfully");
-    Ok(())
-}
-
-fn test_issue_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+fn test_issue_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /issue command with bug report...");
 
-    
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/issue \"Bug: Q CLI crashes when using large files\"")?;
 
     println!("📝 Issue command response: {} bytes", response.len());
@@ -31,12 +31,24 @@ fn test_issue_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error:
     println!("✅ Found browser opening confirmation");
 
     println!("✅ All issue command functionality verified!");
+
+    // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }
 
-fn test_issue_force_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+#[test]
+#[cfg(feature = "issue_reporting")]
+fn test_issue_force_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /issue --force command with critical bug...");
 
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
+
     let response = chat.execute_command("/issue --force \"Critical bug in file handling\"")?;
 
     println!("📝 Issue force command response: {} bytes", response.len());
@@ -49,11 +61,23 @@ fn test_issue_force_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::
     println!("✅ Found browser opening confirmation");
 
     println!("✅ All issue --force command functionality verified!");
+
+    // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }
 
-fn test_issue_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::error::Error>> {
+#[test]
+#[cfg(feature = "issue_reporting")]
+fn test_issue_help_command() -> Result<(), Box<dyn std::error::Error>> {
     println!("🔍 Testing /issue --help command...");
+     
+    let session = get_chat_session();
+    let mut chat = session.lock().unwrap();
 
     let response = chat.execute_command("/issue --help")?;
 
@@ -83,6 +107,13 @@ fn test_issue_help_command(chat: &mut QChatSession) -> Result<(), Box<dyn std::e
     println!("✅ Found Options section with force and help flags");
 
     println!("✅ All issue help content verified!");
+
+     // Release the lock before cleanup
+    drop(chat);
+    
+    // Cleanup only if this is the last test
+    cleanup_if_last_test(&TEST_COUNT, TOTAL_TESTS)?;
+
     Ok(())
 }