Merge pull request #226 from codesandbox/add-full-e2e-tests

chore: add e2e tests for sdk

Author: mojojoji

package.json

@@ -55,6 +55,7 @@
     "build-openapi-pint": "node_modules/.bin/openapi-ts -i ./pint-openapi-bundled.json -o src/api-clients/pint -c @hey-api/client-fetch",
     "clean": "rimraf ./dist",
     "test": "vitest",
+    "test:e2e": "vitest run tests/e2e",
     "typecheck": "tsc --noEmit",
     "format": "prettier '**/*.{md,js,jsx,json,ts,tsx}' --write",
     "postbuild": "rimraf {lib,es}/**/__tests__ {lib,es}/**/*.{spec,test}.{js,d.ts,js.map}",

tests/e2e/helpers.ts

@@ -0,0 +1,38 @@
+import { CodeSandbox } from '../../src/index.js';
+
+/**
+ * Test template ID used across e2e tests
+ */
+export const TEST_TEMPLATE_ID = process.env.CSB_TEST_TEMPLATE_ID ?? 'pt_6FknW3VwS874LKWUQ83jir';
+
+/**
+ * Initialize SDK with API key from environment
+ */
+export function initializeSDK(): CodeSandbox {
+  const apiKey = process.env.CSB_API_KEY;
+  if (!apiKey) {
+    throw new Error('CSB_API_KEY environment variable is required for e2e tests');
+  }
+  return new CodeSandbox(apiKey);
+}
+
+/**
+ * Retry a check function until it returns truthy or timeout is reached
+ */
+export async function retryUntil<T>(
+  timeoutMs: number,
+  intervalMs: number,
+  checkFunction: () => Promise<T | null | undefined | false>
+): Promise<T | null> {
+  const startTime = Date.now();
+  let result: T | null | undefined | false = false;
+
+  while (Date.now() - startTime < timeoutMs && !result) {
+    result = await checkFunction();
+    if (!result) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+  }
+
+  return result || null;
+}

tests/e2e/sandbox-apis.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { CodeSandbox } from '../../src/index.js';
+import { initializeSDK, TEST_TEMPLATE_ID, retryUntil } from './helpers.js';
+
+describe('Sandbox APIs', () => {
+  let sdk: CodeSandbox;
+  let sandboxId: string | undefined;
+
+  beforeAll(async () => {
+    sdk = initializeSDK();
+
+    // Create a sandbox for testing
+    const sandbox = await sdk.sandboxes.create({
+      id: TEST_TEMPLATE_ID,
+    });
+    sandboxId = sandbox.id;
+  });
+
+  afterAll(async () => {
+    // Cleanup: shutdown and delete the sandbox
+    if (sandboxId) {
+      try {
+        await sdk.sandboxes.shutdown(sandboxId);
+        await sdk.sandboxes.delete(sandboxId);
+      } catch (error) {
+        console.error('Failed to cleanup test sandbox:', sandboxId, error);
+        // Try to force delete even if shutdown fails
+        try {
+          await sdk.sandboxes.delete(sandboxId);
+        } catch (deleteError) {
+          console.error('Failed to force delete sandbox:', sandboxId, deleteError);
+        }
+      }
+    }
+  });
+
+  it('should find sandbox in list', async () => {
+    expect(sandboxId).toBeDefined();
+    if (!sandboxId) throw new Error('Sandbox not created');
+
+    const sandboxes = await sdk.sandboxes.list();
+    expect(sandboxes).toBeDefined();
+    expect(sandboxes.sandboxes).toBeDefined();
+
+    const found = sandboxes.sandboxes.find((s) => s.id === sandboxId);
+    expect(found).toBeDefined();
+  });
+
+  it('should find sandbox in running list by filter', async () => {
+    expect(sandboxId).toBeDefined();
+    if (!sandboxId) throw new Error('Sandbox not created');
+
+    const foundInList = await retryUntil(60000, 3000, async () => {
+      const runningSandboxesByFilter = await sdk.sandboxes.list({
+        status: 'running',
+      });
+      return runningSandboxesByFilter.sandboxes.find((s) => s.id === sandboxId);
+    });
+
+    expect(foundInList).toBeDefined();
+  }, 70000);
+
+  it('should find sandbox in running list by API', async () => {
+    expect(sandboxId).toBeDefined();
+    if (!sandboxId) throw new Error('Sandbox not created');
+
+    const foundByAPI = await retryUntil(60000, 3000, async () => {
+      const runningSandboxByAPI = await sdk.sandboxes.listRunning();
+      return runningSandboxByAPI.vms.find((s) => s.id === sandboxId);
+    });
+
+    expect(foundByAPI).toBeDefined();
+  }, 70000);
+
+  it('should get sandbox by ID', async () => {
+    expect(sandboxId).toBeDefined();
+    if (!sandboxId) throw new Error('Sandbox not created');
+
+    const fetchedSandbox = await sdk.sandboxes.get(sandboxId);
+    expect(fetchedSandbox).toBeDefined();
+    expect(fetchedSandbox.id).toBe(sandboxId);
+  });
+});

tests/e2e/sandbox-commands.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { CodeSandbox } from '../../src/index.js';
+import { Sandbox } from '../../src/Sandbox.js';
+import { SandboxClient } from '../../src/SandboxClient/index.js';
+import { initializeSDK, TEST_TEMPLATE_ID } from './helpers.js';
+
+describe('Sandbox Commands', () => {
+  let sdk: CodeSandbox;
+  let sandbox: Sandbox | undefined;
+  let client: SandboxClient | undefined;
+
+  beforeAll(async () => {
+    sdk = initializeSDK();
+
+    // Create a sandbox for testing
+    sandbox = await sdk.sandboxes.create({
+      id: TEST_TEMPLATE_ID,
+    });
+
+    // Connect to sandbox
+    client = await sandbox.connect();
+  }, 60000);
+
+  afterAll(async () => {
+    const sandboxId = sandbox?.id;
+
+    try {
+      if (client) {
+        await client.disconnect();
+        client.dispose();
+        client = undefined;
+      }
+    } catch (error) {
+      console.error('Failed to dispose client:', error);
+    }
+
+    if (sandboxId) {
+      try {
+        await sdk.sandboxes.shutdown(sandboxId);
+        await sdk.sandboxes.delete(sandboxId);
+      } catch (error) {
+        console.error('Failed to cleanup test sandbox:', sandboxId, error);
+        try {
+          await sdk.sandboxes.delete(sandboxId);
+        } catch (deleteError) {
+          console.error('Failed to force delete sandbox:', sandboxId, deleteError);
+        }
+      }
+    }
+  });
+
+  describe('Command execution', () => {
+    it('should run a simple command and get output', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const output = await client.commands.run('echo "Hello from sandbox"');
+      expect(output).toContain('Hello from sandbox');
+    });
+
+    it('should get output from pwd command', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const output = await client.commands.run('pwd');
+      expect(output).toBeTruthy();
+      expect(output.trim()).toMatch(/^\//); // Should start with /
+    });
+
+    it('should run multiple commands sequentially', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const output1 = await client.commands.run('echo "first"');
+      const output2 = await client.commands.run('echo "second"');
+      const output3 = await client.commands.run('echo "third"');
+
+      expect(output1).toContain('first');
+      expect(output2).toContain('second');
+      expect(output3).toContain('third');
+    });
+
+    it('should run multiple commands with array syntax', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      // Array of commands should be joined with &&
+      const output = await client.commands.run([
+        'echo "first"',
+        'echo "second"',
+        'echo "third"',
+      ]);
+
+      expect(output).toContain('first');
+      expect(output).toContain('second');
+      expect(output).toContain('third');
+    });
+  });
+
+  describe('Background commands', () => {
+    it('should run command in background', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const command = await client.commands.runBackground('sleep 1 && echo "done"');
+      expect(command).toBeDefined();
+      expect(command.status).toBe('RUNNING');
+
+      // Wait for completion
+      const output = await command.waitUntilComplete();
+      expect(output).toContain('done');
+    }, 10000);
+
+    it('should run multiple commands in background with array syntax', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      // Array of commands should be joined with &&
+      const command = await client.commands.runBackground([
+        'echo "first"',
+        'echo "second"',
+        'echo "third"',
+      ]);
+      expect(command).toBeDefined();
+      expect(command.status).toBe('RUNNING');
+
+      // Wait for completion
+      const output = await command.waitUntilComplete();
+      expect(output).toContain('first');
+      expect(output).toContain('second');
+      expect(output).toContain('third');
+    }, 10000);
+
+    it('should be able to kill background command', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const command = await client.commands.runBackground('sleep 30');
+      expect(command).toBeDefined();
+
+      await command.kill();
+
+      // Command should be killed
+      expect(command).toBeDefined();
+    }, 10000);
+  });
+
+  describe('Command listing', () => {
+    it('should get all commands', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const commands = await client.commands.getAll();
+      expect(Array.isArray(commands)).toBe(true);
+    });
+  });
+
+  describe('Working directory', () => {
+    it('should run command in specified directory', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      // Create a test directory
+      await client.fs.mkdir('/test-cwd');
+
+      const output = await client.commands.run('pwd', { cwd: '/test-cwd' });
+      expect(output).toContain('/test-cwd');
+
+      // Cleanup
+      await client.fs.remove('/test-cwd');
+    });
+  });
+
+  describe('Environment variables', () => {
+    it('should run command with custom environment variables', async () => {
+      if (!client || !sandbox) throw new Error('Client or sandbox not initialized');
+
+      const output = await client.commands.run('echo $TEST_VAR', {
+        env: { TEST_VAR: 'custom_value' },
+      });
+      expect(output).toContain('custom_value');
+    });
+  });
+});