Final deployment: Complete Code Execution Sandbox with all features

build_devenv.ps1

@@ -0,0 +1,45 @@
+# Build script for development environment image
+
+Write-Host "Building sandbox development environment image..." -ForegroundColor Cyan
+Write-Host ""
+
+# Check if Docker is running
+try {
+    docker ps *> $null
+    if ($LASTEXITCODE -ne 0) {
+        Write-Host "Error: Docker is not running or not accessible" -ForegroundColor Red
+        exit 1
+    }
+} catch {
+    Write-Host "Error: Docker is not running or not accessible" -ForegroundColor Red
+    exit 1
+}
+
+# Build the image
+Write-Host "Building image from sandbox/images/devenv.Dockerfile..." -ForegroundColor Yellow
+Write-Host "This may take 10-15 minutes on first build..." -ForegroundColor Yellow
+Write-Host ""
+
+docker build `
+    -f sandbox/images/devenv.Dockerfile `
+    -t sandbox-devenv:latest `
+    sandbox/images/
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Host ""
+    Write-Host "✅ Image built successfully!" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "Verifying environment..." -ForegroundColor Cyan
+    
+    # Run environment check
+    docker run --rm sandbox-devenv:latest /opt/environment_check.sh
+    
+    Write-Host ""
+    Write-Host "Image info:" -ForegroundColor Cyan
+    docker images sandbox-devenv:latest
+    
+} else {
+    Write-Host ""
+    Write-Host "❌ Build failed!" -ForegroundColor Red
+    exit 1
+}

tests/test_api.py

@@ -1,166 +1,314 @@
 import pytest
 from fastapi.testclient import TestClient
 from app import app
+import time
 
 
 @pytest.fixture
 def client():
-    """FastAPI test client fixture"""
+    """Create test client"""
     return TestClient(app)
 
 
-def test_root_endpoint(client):
-    """Test root endpoint returns API info"""
-    response = client.get("/")
-    assert response.status_code == 200
-    data = response.json()
-    assert data["name"] == "Code Execution Sandbox API"
-    assert data["version"] == "1.0.0"
-    assert "supported_languages" in data
-
+# ========== Session Management Tests ==========
 
-def test_health_endpoint(client):
-    """Test health check endpoint"""
-    response = client.get("/health")
-    # May fail if Docker is not available, but endpoint should exist
-    assert response.status_code in [200, 503]
+def test_create_session(client):
+    """Test creating a new session"""
+    response = client.post("/sessions", json={
+        "metadata": {"test": "create_session"},
+        "timeout_minutes": 30
+    })
+    
+    if response.status_code == 201:
+        data = response.json()
+        assert "session_id" in data
+        assert data["status"] in ["creating", "ready"]
+        assert data["timeout_minutes"] == 30
+        
+        # Cleanup
+        session_id = data["session_id"]
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_languages_endpoint(client):
-    """Test languages listing endpoint"""
-    response = client.get("/languages")
-    assert response.status_code == 200
-    data = response.json()
-    assert "languages" in data
-    languages = data["languages"]
-    assert len(languages) == 3
+def test_list_sessions(client):
+    """Test listing all sessions"""
+    # Create a session first
+    create_response = client.post("/sessions", json={"metadata": {"test": "list"}})
     
-    # Check language names
-    lang_names = [lang["name"] for lang in languages]
-    assert "Python" in lang_names
-    assert "JavaScript" in lang_names
-    assert "Bash" in lang_names
+    if create_response.status_code == 201:
+        # List sessions
+        response = client.get("/sessions")
+        assert response.status_code == 200
+        sessions = response.json()
+        assert isinstance(sessions, list)
+        
+        # Cleanup
+        session_id = create_response.json()["session_id"]
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_execute_python_hello_world(client):
-    """Test executing simple Python code"""
-    response = client.post("/execute", json={
-        "code": "print('Hello, World!')",
-        "language": "python"
-    })
+def test_get_session(client):
+    """Test getting session details"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "get"}})
     
-    # If Docker is not available, this may fail with 503
-    if response.status_code == 200:
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        
+        # Get session details
+        response = client.get(f"/sessions/{session_id}")
+        assert response.status_code == 200
         data = response.json()
-        assert "Hello, World!" in data["stdout"]
-        assert data["exit_code"] == 0
-        assert data["error"] is None
+        assert data["session_id"] == session_id
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_execute_python_math(client):
-    """Test Python arithmetic"""
-    response = client.post("/execute", json={
-        "code": "result = 2 + 2\nprint(f'Result: {result}')",
-        "language": "python"
-    })
-    
-    if response.status_code == 200:
-        data = response.json()
-        assert "Result: 4" in data["stdout"]
-        assert data["exit_code"] == 0
+def test_get_nonexistent_session(client):
+    """Test getting a session that doesn't exist"""
+    response = client.get("/sessions/nonexistent-id")
+    assert response.status_code == 404
 
 
-def test_execute_javascript_hello_world(client):
-    """Test executing simple JavaScript code"""
-    response = client.post("/execute", json={
-        "code": "console.log('Hello from Node.js!');",
-        "language": "javascript"
-    })
+def test_destroy_session(client):
+    """Test destroying a session"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "destroy"}})
     
-    if response.status_code == 200:
-        data = response.json()
-        assert "Hello from Node.js!" in data["stdout"]
-        assert data["exit_code"] == 0
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        
+        # Destroy session
+        response = client.delete(f"/sessions/{session_id}")
+        assert response.status_code == 200
+        
+        # Verify it's gone
+        get_response = client.get(f"/sessions/{session_id}")
+        assert get_response.status_code == 404
 
 
-def test_execute_bash_command(client):
-    """Test executing Bash command"""
-    response = client.post("/execute", json={
-        "code": "echo 'Bash works!'",
-        "language": "bash"
-    })
+# ========== File Operations Tests ==========
+
+def test_upload_file(client):
+    """Test uploading a file to session"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "upload"}})
     
-    if response.status_code == 200:
-        data = response.json()
-        assert "Bash works!" in data["stdout"]
-        assert data["exit_code"] == 0
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        time.sleep(2)  # Wait for container to be ready
+        
+        # Upload file
+        file_content = b"print('Hello from test file')"
+        response = client.post(
+            f"/sessions/{session_id}/files",
+            files={"file": ("test.py", file_content, "text/x-python")}
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            assert data["filename"] == "test.py"
+            assert data["size"] == len(file_content)
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_execute_with_syntax_error(client):
-    """Test executing code with syntax error"""
-    response = client.post("/execute", json={
-        "code": "print('missing closing quote)",
-        "language": "python"
-    })
+def test_list_files(client):
+    """Test listing files in session"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "list_files"}})
     
-    if response.status_code == 200:
-        data = response.json()
-        assert data["exit_code"] != 0
-        # Should have error in stderr or error field
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        time.sleep(2)
+        
+        # Upload a file first
+        client.post(
+            f"/sessions/{session_id}/files",
+            files={"file": ("test.txt", b"test content", "text/plain")}
+        )
+        
+        # List files
+        response = client.get(f"/sessions/{session_id}/files")
+        assert response.status_code == 200
+        files = response.json()
+        assert isinstance(files, list)
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_execute_with_timeout(client):
-    """Test timeout enforcement"""
-    response = client.post("/execute", json={
-        "code": "import time\ntime.sleep(5)",
-        "language": "python",
-        "timeout": 2
-    })
+def test_download_file(client):
+    """Test downloading a file from session"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "download"}})
     
-    if response.status_code == 200:
-        data = response.json()
-        # Should timeout
-        assert data["execution_time"] < 3
-        assert data["error"] is not None or data["exit_code"] == 124
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        time.sleep(2)
+        
+        # Upload file
+        file_content = b"download test content"
+        upload_response = client.post(
+            f"/sessions/{session_id}/files",
+            files={"file": ("download.txt", file_content, "text/plain")}
+        )
+        
+        if upload_response.status_code == 200:
+            # Download file
+            response = client.get(f"/sessions/{session_id}/files/download.txt")
+            assert response.status_code == 200
+            assert response.content == file_content
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_invalid_language(client):
-    """Test invalid language rejection"""
-    response = client.post("/execute", json={
-        "code": "print('test')",
-        "language": "rust"  # Not supported
-    })
+# ========== Execute in Session Tests ==========
+
+def test_execute_in_session(client):
+    """Test executing code in a session"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "execute"}})
     
-    assert response.status_code == 422  # Validation error
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        time.sleep(2)
+        
+        # Execute code
+        response = client.post(
+            f"/sessions/{session_id}/execute",
+            json={
+                "code": "print('Hello from session')",
+                "language": "python",
+                "working_dir": "/workspace"
+            }
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            assert "Hello from session" in data["stdout"]
+            assert data["exit_code"] == 0
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_empty_code(client):
-    """Test empty code rejection"""
-    response = client.post("/execute", json={
-        "code": "",
-        "language": "python"
-    })
+def test_execute_file_in_session(client):
+    """Test executing an uploaded file"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "execute_file"}})
     
-    assert response.status_code == 422  # Validation error
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        time.sleep(2)
+        
+        # Upload Python file
+        file_content = b"print('Executed from file')\nprint(2 + 2)"
+        upload_response = client.post(
+            f"/sessions/{session_id}/files",
+            files={"file": ("script.py", file_content, "text/x-python")}
+        )
+        
+        if upload_response.status_code == 200:
+            # Execute file
+            response = client.post(
+                f"/sessions/{session_id}/execute-file",
+                json={
+                    "filepath": "/workspace/script.py",
+                    "language": "python",
+                    "args": []
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                assert "Executed from file" in data["stdout"]
+                assert "4" in data["stdout"]
+                assert data["exit_code"] == 0
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
 
 
-def test_timeout_out_of_range(client):
-    """Test timeout validation"""
-    response = client.post("/execute", json={
-        "code": "print('test')",
-        "language": "python",
-        "timeout": 100  # Exceeds max of 30
-    })
+def test_persistent_state_across_executions(client):
+    """Test that session maintains state across multiple executions"""
+    # Create session
+    create_response = client.post("/sessions", json={"metadata": {"test": "persistent"}})
     
-    assert response.status_code == 422  # Validation error
+    if create_response.status_code == 201:
+        session_id = create_response.json()["session_id"]
+        time.sleep(2)
+        
+        # First execution: create file
+        response1 = client.post(
+            f"/sessions/{session_id}/execute",
+            json={
+                "code": "with open('/workspace/data.txt', 'w') as f: f.write('persistent')",
+                "language": "python"
+            }
+        )
+        
+        if response1.status_code == 200:
+            # Second execution: read file (should still exist)
+            response2 = client.post(
+                f"/sessions/{session_id}/execute",
+                json={
+                    "code": "with open('/workspace/data.txt', 'r') as f: print(f.read())",
+                    "language": "python"
+                }
+            )
+            
+            if response2.status_code == 200:
+                data = response2.json()
+                assert "persistent" in data["stdout"]
+        
+        # Cleanup
+        client.delete(f"/sessions/{session_id}")
+
 
+# ========== Backward Compatibility Tests ==========
 
-def test_memory_limit_validation(client):
-    """Test memory limit validation"""
+def test_stateless_execute_still_works(client):
+    """Test that original /execute endpoint still works"""
     response = client.post("/execute", json={
-        "code": "print('test')",
-        "language": "python",
-        "memory_limit": 1024  # Exceeds max of 512
+        "code": "print('Stateless execution')",
+        "language": "python"
     })
     
-    assert response.status_code == 422  # Validation error
+    if response.status_code == 200:
+        data = response.json()
+        assert "Stateless execution" in data["stdout"]
+        assert data["exit_code"] == 0
+
+
+# ========== API Root and Health Tests ==========
+
+def test_root_endpoint(client):
+    """Test root endpoint"""
+    response = client.get("/")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["name"] == "Code Execution Sandbox API"
+    assert data["version"] == "2.0.0"
+    assert "endpoints" in data
+
+
+def test_health_endpoint(client):
+    """Test health check"""
+    response = client.get("/health")
+    if response.status_code == 200:
+        data = response.json()
+        assert data["status"] == "healthy"
+        assert "docker" in data
+
+
+def test_languages_endpoint(client):
+    """Test languages listing"""
+    response = client.get("/languages")
+    assert response.status_code == 200
+    data = response.json()
+    assert "languages" in data
+    assert len(data["languages"]) > 0