Private instance vars, public get properties

test/delete_command_test.py

@@ -1,18 +1,59 @@
-import unittest
 from datetime import datetime
+import os
 import time
+import unittest
 
 from sia.working_memory import WorkingMemory
 from sia.delete_command import DeleteCommand
 from sia.reasoning_entry import ReasoningEntry
 from sia.background_entry import BackgroundEntry
 
+
+
 class DeleteCommandTest(unittest.TestCase):
     def setUp(self):
         """Set up test cases with a fresh working memory"""
         self.memory = WorkingMemory()
         self.test_id = "test-id-1234"
         self.test_timestamp = datetime(2024, 10, 31, 12, 0, 0)
+
+    def wait_for_process_start(self, entry: BackgroundEntry, timeout=1.0):
+        """Wait for process to start, checking context pid"""
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            entry.update()
+            context = entry.generate_context()
+            if context.get("pid") is not None:
+                return True
+            time.sleep(0.1)
+        return False
+        
+    def test_delete_running_background_entry(self):
+        """Test deleting a background entry that is still running"""
+        # Create and start background process
+        entry = BackgroundEntry("sleep 10", "test-id", self.test_timestamp)
+        self.memory.add_entry(entry)
+        
+        # Wait for process to start
+        self.assertTrue(self.wait_for_process_start(entry))
+        
+        # Get PID before deletion
+        context = entry.generate_context()
+        pid = int(context.get("pid"))
+        
+        # Delete entry and verify process terminated
+        command = DeleteCommand(entry.id)
+        result = command.execute(self.memory)
+        
+        self.assertTrue(result.success)
+        self.assertFalse(result.should_stop)
+        self.assertEqual(result.message, "")
+        self.assertEqual(self.memory.get_entries_count(), 0)
+        
+        # Verify process was terminated
+        time.sleep(0.1)  # Give process time to terminate
+        with self.assertRaises(ProcessLookupError):
+            os.kill(pid, 0)
         
     def test_delete_existing_entry(self):
         """Test deleting an existing entry"""
@@ -29,31 +70,6 @@ class DeleteCommandTest(unittest.TestCase):
         self.assertFalse(result.should_stop)
         self.assertEqual(result.message, "")
         self.assertEqual(self.memory.get_entries_count(), 0)
-        
-    def test_delete_running_background_entry(self):
-        """Test deleting a background entry that is still running"""
-        # Create a background entry with a long-running command
-        entry = BackgroundEntry("sleep 10", self.test_id, self.test_timestamp)
-        self.memory.add_entry(entry)
-        
-        # Start the process
-        entry.update()
-        self.assertIsNotNone(entry.process)
-        process_pid = entry.process.pid
-        
-        # Execute delete command
-        command = DeleteCommand(self.test_id)
-        result = command.execute(self.memory)
-        
-        # Verify process was terminated
-        time.sleep(0.1)  # Give process time to terminate
-        self.assertTrue(result.success)
-        self.assertIsNone(entry.process)
-        
-        # Verify process no longer exists
-        with self.assertRaises(ProcessLookupError):
-            import os
-            os.kill(process_pid, 0)
             
     def test_delete_nonexistent_entry(self):
         """Test attempting to delete a nonexistent entry"""