added tests

Author: mishushakov

js/tests/supervisord.test.ts

@@ -0,0 +1,49 @@
+import { expect } from 'vitest'
+import { sandboxTest, wait } from './setup'
+
+async function waitForHealth(sandbox: any, maxRetries = 10, intervalMs = 100) {
+  for (let i = 0; i < maxRetries; i++) {
+    const result = await sandbox.commands.run(
+      'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
+    )
+    if (result.stdout.trim() === '200') {
+      return true
+    }
+    await wait(intervalMs)
+  }
+  return false
+}
+
+sandboxTest('restart after jupyter kill', async ({ sandbox }) => {
+  // Verify health is up initially
+  const initialHealth = await waitForHealth(sandbox)
+  expect(initialHealth).toBe(true)
+
+  // Kill the jupyter process
+  await sandbox.commands.run('supervisorctl stop jupyter')
+
+  // Wait for supervisord to restart it and health to come back
+  const recovered = await waitForHealth(sandbox, 10, 100)
+  expect(recovered).toBe(true)
+
+  // Verify code execution works after recovery
+  const result = await sandbox.runCode('x = 1; x')
+  expect(result.text).toEqual('1')
+})
+
+sandboxTest('restart after code-interpreter kill', async ({ sandbox }) => {
+  // Verify health is up initially
+  const initialHealth = await waitForHealth(sandbox)
+  expect(initialHealth).toBe(true)
+
+  // Kill the code-interpreter process
+  await sandbox.commands.run('supervisorctl stop code-interpreter')
+
+  // Wait for supervisord to restart it and health to come back
+  const recovered = await waitForHealth(sandbox, 10, 100)
+  expect(recovered).toBe(true)
+
+  // Verify code execution works after recovery
+  const result = await sandbox.runCode('x = 1; x')
+  expect(result.text).toEqual('1')
+})

python/tests/async/test_async_supervisord.py

@@ -0,0 +1,44 @@
+import asyncio
+
+from e2b_code_interpreter.code_interpreter_async import AsyncSandbox
+
+
+async def wait_for_health(sandbox: AsyncSandbox, max_retries=10, interval_ms=100):
+    for _ in range(max_retries):
+        result = await sandbox.commands.run(
+            'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
+        )
+        if result.stdout.strip() == "200":
+            return True
+        await asyncio.sleep(interval_ms / 1000)
+    return False
+
+
+async def test_restart_after_jupyter_kill(async_sandbox: AsyncSandbox):
+    # Verify health is up initially
+    assert await wait_for_health(async_sandbox)
+
+    # Kill the jupyter process
+    await async_sandbox.commands.run("supervisorctl stop jupyter")
+
+    # Wait for supervisord to restart it and health to come back
+    assert await wait_for_health(async_sandbox, 10, 100)
+
+    # Verify code execution works after recovery
+    result = await async_sandbox.run_code("x = 1; x")
+    assert result.text == "1"
+
+
+async def test_restart_after_code_interpreter_kill(async_sandbox: AsyncSandbox):
+    # Verify health is up initially
+    assert await wait_for_health(async_sandbox)
+
+    # Kill the code-interpreter process
+    await async_sandbox.commands.run("supervisorctl stop code-interpreter")
+
+    # Wait for supervisord to restart it and health to come back
+    assert await wait_for_health(async_sandbox, 10, 100)
+
+    # Verify code execution works after recovery
+    result = await async_sandbox.run_code("x = 1; x")
+    assert result.text == "1"

python/tests/sync/test_supervisord.py

@@ -0,0 +1,44 @@
+import time
+
+from e2b_code_interpreter.code_interpreter_sync import Sandbox
+
+
+def wait_for_health(sandbox: Sandbox, max_retries=10, interval_ms=100):
+    for _ in range(max_retries):
+        result = sandbox.commands.run(
+            'curl -s -o /dev/null -w "%{http_code}" http://0.0.0.0:49999/health'
+        )
+        if result.stdout.strip() == "200":
+            return True
+        time.sleep(interval_ms / 1000)
+    return False
+
+
+def test_restart_after_jupyter_kill(sandbox: Sandbox):
+    # Verify health is up initially
+    assert wait_for_health(sandbox)
+
+    # Kill the jupyter process
+    sandbox.commands.run("supervisorctl stop jupyter")
+
+    # Wait for supervisord to restart it and health to come back
+    assert wait_for_health(sandbox, 10, 100)
+
+    # Verify code execution works after recovery
+    result = sandbox.run_code("x = 1; x")
+    assert result.text == "1"
+
+
+def test_restart_after_code_interpreter_kill(sandbox: Sandbox):
+    # Verify health is up initially
+    assert wait_for_health(sandbox)
+
+    # Kill the code-interpreter process
+    sandbox.commands.run("supervisorctl stop code-interpreter")
+
+    # Wait for supervisord to restart it and health to come back
+    assert wait_for_health(sandbox, 10, 100)
+
+    # Verify code execution works after recovery
+    result = sandbox.run_code("x = 1; x")
+    assert result.text == "1"