fix test

Signed-off-by: kerthcet <kerthcet@gmail.com>

Author: kerthcet

examples/programmatic_session.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+Example: Programmatic Session Control
+
+Demonstrates how to use non-interactive sessions for:
+- Multi-step command sequences
+- Inspecting session output programmatically
+- Handling session state and errors
+- Building automation scripts
+"""
+
+import sys
+import time
+from sandd import Server
+
+
+def main():
+    # Start server
+    server = Server("0.0.0.0", 8765)
+    print(f"Server listening on {server.address}")
+
+    # Wait for daemon
+    daemon_id = "daemon-1"
+    print(f"\nWaiting for daemon '{daemon_id}'...")
+    if not server.wait_for_daemon(daemon_id, timeout=30):
+        print(f"Daemon '{daemon_id}' did not connect")
+        sys.exit(1)
+
+    print(f"Daemon '{daemon_id}' connected!\n")
+
+    # Create a non-interactive session
+    print("=== Creating Session ===")
+    session = server.new_session(daemon_id, rows=24, cols=80)
+    print("Session created\n")
+
+    # Example 1: Execute command and capture output
+    print("=== Example 1: Basic Command ===")
+    session.write(b"echo 'Hello from session'\n")
+    time.sleep(0.2)
+    output = session.read(timeout=1.0)
+    if output:
+        print(f"Output: {output.decode()}")
+
+    # Example 2: Multi-step workflow
+    print("\n=== Example 2: Multi-Step Workflow ===")
+    steps = [
+        ("mkdir -p /tmp/test", "Creating directory"),
+        ("cd /tmp/test", "Changing directory"),
+        ("pwd", "Verifying location"),
+        ("echo 'test' > file.txt", "Creating file"),
+        ("cat file.txt", "Reading file"),
+    ]
+
+    for cmd, description in steps:
+        print(f"{description}: {cmd}")
+        session.write(f"{cmd}\n".encode())
+        time.sleep(0.1)
+        output = session.read(timeout=1.0)
+        if output:
+            result = output.decode().strip()
+            if result:
+                print(f"  → {result}")
+
+    # Example 3: Error handling
+    print("\n=== Example 3: Error Handling ===")
+    session.write(b"exit 42\n")  # Exit with non-zero code
+    time.sleep(0.2)
+
+    # Try to write after exit - should fail gracefully
+    try:
+        session.write(b"echo 'after exit'\n")
+        output = session.read(timeout=1.0)
+        if output:
+            print(f"Output: {output.decode()}")
+    except Exception as e:
+        print(f"Session closed (expected): {e}")
+
+    # Example 4: Create new session for long-running task
+    print("\n=== Example 4: Long-Running Task ===")
+    session2 = server.new_session(daemon_id)
+    session2.write(b"for i in 1 2 3; do echo \"Step $i\"; sleep 1; done\n")
+
+    # Stream output as it arrives
+    start = time.time()
+    while time.time() - start < 5:
+        output = session2.read(timeout=0.5)
+        if output:
+            print(output.decode(), end='', flush=True)
+        else:
+            break
+
+    session2.close()
+    print("\n\nSession closed")
+
+
+if __name__ == "__main__":
+    main()

python/tests/test_e2e.py

@@ -107,6 +107,42 @@ def run_cmd(daemon_id):
         assert all(r.success for r in results)
         assert all("Response from" in r.stdout for r in results)
 
+    def test_concurrent_execution_same_daemon(self, server):
+        """Execute multiple commands concurrently on the same daemon"""
+        import concurrent.futures
+        import time
+
+        daemon_id = "daemon-debian-1"
+
+        def run_sleep(n):
+            start = time.time()
+            result = server.exec(daemon_id, f"sleep {n} && echo 'slept {n}s'", timeout=10)
+            duration = time.time() - start
+            return result, duration
+
+        def run_fast():
+            start = time.time()
+            result = server.exec(daemon_id, "echo 'fast command'", timeout=5)
+            duration = time.time() - start
+            return result, duration
+
+        # Start slow command (3s) and fast command concurrently
+        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+            slow_future = executor.submit(run_sleep, 3)
+            fast_future = executor.submit(run_fast)
+
+            # Fast command should complete quickly, not wait for slow one
+            fast_result, fast_duration = fast_future.result()
+            assert fast_result.success
+            assert "fast command" in fast_result.stdout
+            assert fast_duration < 1.0  # Should finish in <1s, not wait for 3s sleep
+
+            # Slow command completes independently
+            slow_result, slow_duration = slow_future.result()
+            assert slow_result.success
+            assert "slept 3s" in slow_result.stdout
+            assert 2.5 < slow_duration < 4.0
+
 
 class TestE2ELabels:
     """Test label-based filtering in E2E"""
@@ -289,18 +325,22 @@ def test_session_multiline_commands(self, server):
 
         try:
             # Send multi-line command
-            session.write(b"for i in 1 2 3; do\n")
-            time.sleep(0.2)
-            session.write(b"echo $i\n")
-            time.sleep(0.2)
-            session.write(b"done\n")
+            session.write(b"for i in 1 2 3; do echo $i; done\n")
             time.sleep(0.5)
 
-            output = session.read(timeout=2.0)
-            assert output is not None
-            output_str = output.decode('utf-8', errors='ignore')
+            # Read all output chunks
+            all_output = b''
+            for _ in range(5):
+                output = session.read(timeout=0.5)
+                if output:
+                    all_output += output
+                else:
+                    break
+
+            assert all_output
+            output_str = all_output.decode('utf-8', errors='ignore')
             # Should see the numbers
-            assert '1' in output_str and '2' in output_str
+            assert '1' in output_str and '2' in output_str and '3' in output_str
 
         finally:
             session.close()