API Testing Automation Platform

from hopx_ai import Sandbox
import os
import json
from typing import Dict, Any

class APITestRunner:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.sandbox = None
    
    def initialize(self):
        """Initialize test sandbox"""
        self.sandbox = Sandbox.create(
            template="code-interpreter",
            api_key=self.api_key,
            timeout_seconds=600
        )
        
        # Install requests library
        self.sandbox.commands.run("pip install requests", timeout=30)
    
    def run_test(self, test_code: str, env_vars: Dict[str, str] = None) -> Dict[str, Any]:
        """Execute API test"""
        try:
            # Set environment variables
            if env_vars:
                self.sandbox.env.set_all(env_vars)
            
            # Execute test
            result = self.sandbox.run_code(test_code, timeout=30)
            
            # Parse test results
            test_results = self._parse_test_results(result.stdout)
            
            return {
                "success": result.success and test_results.get("all_passed", False),
                "stdout": result.stdout,
                "stderr": result.stderr,
                "test_results": test_results,
                "execution_time": result.execution_time
            }
        except Exception as e:
            return {
                "success": False,
                "error": str(e)
            }
    
    def _parse_test_results(self, output: str) -> Dict[str, Any]:
        """Parse test output"""
        # Simple parsing - in production, use proper test framework
        passed = output.count("PASS") or output.count("✓")
        failed = output.count("FAIL") or output.count("✗")
        
        return {
            "all_passed": failed == 0 and passed > 0,
            "passed": passed,
            "failed": failed
        }
    
    def cleanup(self):
        """Clean up test resources"""
        if self.sandbox:
            self.sandbox.kill()
            self.sandbox = None

# Usage
runner = APITestRunner(api_key=os.getenv("HOPX_API_KEY"))
runner.initialize()

test_code = """
import requests
import json

# Test GET endpoint
response = requests.get('https://jsonplaceholder.typicode.com/posts/1')
assert response.status_code == 200, f"Expected 200, got {response.status_code}"
data = response.json()
assert 'userId' in data, "Missing userId field"
print("PASS: GET test")
"""

result = runner.run_test(test_code)
print(json.dumps(result, indent=2))

runner.cleanup()

import { Sandbox } from '@hopx-ai/sdk';

class APITestRunner {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.sandbox = null;
    }
    
    async initialize() {
        this.sandbox = await Sandbox.create({
            template: 'code-interpreter',
            apiKey: this.apiKey,
            timeoutSeconds: 600
        });
        
        // Install axios
        await this.sandbox.commands.run('npm install axios', { timeout: 30 });
    }
    
    async runTest(testCode, envVars = null) {
        try {
            // Set environment variables
            if (envVars) {
                await this.sandbox.env.setAll(envVars);
            }
            
            // Execute test
            const result = await this.sandbox.runCode(testCode, { timeout: 30 });
            
            // Parse test results
            const testResults = this.parseTestResults(result.stdout);
            
            return {
                success: result.success && testResults.allPassed,
                stdout: result.stdout,
                stderr: result.stderr,
                testResults,
                executionTime: result.execution_time
            };
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }
    
    parseTestResults(output) {
        const passed = (output.match(/PASS/g) || []).length || (output.match(/✓/g) || []).length;
        const failed = (output.match(/FAIL/g) || []).length || (output.match(/✗/g) || []).length;
        
        return {
            allPassed: failed === 0 && passed > 0,
            passed,
            failed
        };
    }
    
    async cleanup() {
        if (this.sandbox) {
            await this.sandbox.kill();
            this.sandbox = null;
        }
    }
}

// Usage
const runner = new APITestRunner(process.env.HOPX_API_KEY);
await runner.initialize();

const testCode = `
const axios = require('axios');

// Test GET endpoint
const response = await axios.get('https://jsonplaceholder.typicode.com/posts/1');
if (response.status !== 200) {
    throw new Error(\`Expected 200, got \${response.status}\`);
}
if (!response.data.userId) {
    throw new Error('Missing userId field');
}
console.log('PASS: GET test');
`;

const result = await runner.runTest(testCode);
console.log(JSON.stringify(result, null, 2));

await runner.cleanup();

class EnvironmentManager:
    def __init__(self, sandbox: Sandbox):
        self.sandbox = sandbox
        self.environments = {}
    
    def create_environment(self, env_name: str, variables: Dict[str, str]):
        """Create test environment"""
        self.environments[env_name] = variables
    
    def use_environment(self, env_name: str):
        """Use environment for tests"""
        if env_name in self.environments:
            self.sandbox.env.set_all(self.environments[env_name])
            return True
        return False

# Usage
sandbox = Sandbox.create(template="code-interpreter", api_key=os.getenv("HOPX_API_KEY"))
env_manager = EnvironmentManager(sandbox)

env_manager.create_environment("production", {
    "API_URL": "https://api.example.com",
    "API_KEY": "prod-key-123"
})

env_manager.create_environment("staging", {
    "API_URL": "https://staging-api.example.com",
    "API_KEY": "staging-key-456"
})

env_manager.use_environment("production")
sandbox.kill()

class EnvironmentManager {
    constructor(sandbox) {
        this.sandbox = sandbox;
        this.environments = {};
    }
    
    createEnvironment(envName, variables) {
        this.environments[envName] = variables;
    }
    
    async useEnvironment(envName) {
        if (this.environments[envName]) {
            await this.sandbox.env.setAll(this.environments[envName]);
            return true;
        }
        return false;
    }
}

// Usage
const sandbox = await Sandbox.create({
    template: 'code-interpreter',
    apiKey: process.env.HOPX_API_KEY
});
const envManager = new EnvironmentManager(sandbox);

envManager.createEnvironment('production', {
    API_URL: 'https://api.example.com',
    API_KEY: 'prod-key-123'
});

envManager.createEnvironment('staging', {
    API_URL: 'https://staging-api.example.com',
    API_KEY: 'staging-key-456'
});

await envManager.useEnvironment('production');
await sandbox.kill();