test: add SDK and contract package tests (89 tests)

Author: richiemcilroy

bun.lock

@@ -50,6 +50,22 @@ describe('generateUUIDv7', () => {
     expect(timestamp).toBeGreaterThanOrEqual(before)
     expect(timestamp).toBeLessThanOrEqual(after)
   })
+
+  test('generates unique values across 100 rapid calls', () => {
+    const set = new Set<string>()
+    for (let i = 0; i < 100; i++) {
+      set.add(base62Encode(generateUUIDv7()))
+    }
+    expect(set.size).toBe(100)
+  })
+
+  test('version and variant are consistent across many generations', () => {
+    for (let i = 0; i < 50; i++) {
+      const bytes = generateUUIDv7()
+      expect((bytes[6] >> 4) & 0x0f).toBe(7)
+      expect((bytes[8] >> 6) & 0x03).toBe(2)
+    }
+  })
 })
 
 describe('base62', () => {
@@ -87,6 +103,19 @@ describe('base62', () => {
   test('throws on invalid character', () => {
     expect(() => base62Decode('!'.repeat(22))).toThrow('Invalid base62 character')
   })
+
+  test('encoding is deterministic', () => {
+    const bytes = generateUUIDv7()
+    const a = base62Encode(bytes)
+    const b = base62Encode(bytes)
+    expect(a).toBe(b)
+  })
+
+  test('different bytes produce different encodings', () => {
+    const a = base62Encode(generateUUIDv7())
+    const b = base62Encode(generateUUIDv7())
+    expect(a).not.toBe(b)
+  })
 })
 
 describe('generateId', () => {
@@ -110,6 +139,19 @@ describe('generateId', () => {
     const b = generateId('ex_')
     expect(a < b).toBe(true)
   })
+
+  test('ID starts with the given prefix', () => {
+    const id = generateId('sb_')
+    expect(id.startsWith('sb_')).toBe(true)
+  })
+
+  test('ID length is prefix + 22 base62 chars', () => {
+    const prefixes = ['sb_', 'ex_', 'sess_', 'art_', 'img_', 'prof_', 'node_', 'proj_']
+    for (const prefix of prefixes) {
+      const id = generateId(prefix)
+      expect(id.length).toBe(prefix.length + 22)
+    }
+  })
 })
 
 describe('parseId', () => {
@@ -153,4 +195,46 @@ describe('idToBytes / bytesToId', () => {
     const reconstructed = bytesToId('art_', bytes)
     expect(reconstructed).toBe(id)
   })
+
+  test('idToBytes returns 16 bytes', () => {
+    const id = generateId('sb_')
+    const bytes = idToBytes(id)
+    expect(bytes.length).toBe(16)
+  })
+
+  test('same ID always produces same bytes', () => {
+    const id = generateId('sb_')
+    const a = idToBytes(id)
+    const b = idToBytes(id)
+    expect(a).toEqual(b)
+  })
+})
+
+describe('prefix constants', () => {
+  test('all prefixes end with underscore', () => {
+    const prefixes = [
+      SANDBOX_PREFIX,
+      EXEC_PREFIX,
+      SESSION_PREFIX,
+      ARTIFACT_PREFIX,
+      IMAGE_PREFIX,
+      PROFILE_PREFIX,
+      NODE_PREFIX,
+      PROJECT_PREFIX,
+    ]
+    for (const prefix of prefixes) {
+      expect(prefix.endsWith('_')).toBe(true)
+    }
+  })
+
+  test('prefixes have expected values', () => {
+    expect(SANDBOX_PREFIX).toBe('sb_')
+    expect(EXEC_PREFIX).toBe('ex_')
+    expect(SESSION_PREFIX).toBe('sess_')
+    expect(ARTIFACT_PREFIX).toBe('art_')
+    expect(IMAGE_PREFIX).toBe('img_')
+    expect(PROFILE_PREFIX).toBe('prof_')
+    expect(NODE_PREFIX).toBe('node_')
+    expect(PROJECT_PREFIX).toBe('proj_')
+  })
 })

packages/contract/src/id.test.ts

@@ -14,12 +14,13 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src/",
-    "test": "echo 'no tests yet'"
+    "test": "bun test"
   },
   "dependencies": {
     "@sandchest/contract": "workspace:*"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.9",
     "@types/node": "^25.3.0"
   }
 }

packages/sdk-ts/package.json

@@ -0,0 +1,70 @@
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+import { Sandchest } from './client.js'
+
+describe('Sandchest', () => {
+  const originalEnv = process.env['SANDCHEST_API_KEY']
+
+  beforeEach(() => {
+    delete process.env['SANDCHEST_API_KEY']
+  })
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env['SANDCHEST_API_KEY'] = originalEnv
+    } else {
+      delete process.env['SANDCHEST_API_KEY']
+    }
+  })
+
+  test('throws when no API key is provided and env is unset', () => {
+    expect(() => new Sandchest()).toThrow('Sandchest API key is required')
+  })
+
+  test('accepts API key via options', () => {
+    const client = new Sandchest({ apiKey: 'sk_test_123' })
+    expect(client).toBeInstanceOf(Sandchest)
+  })
+
+  test('reads API key from SANDCHEST_API_KEY env var', () => {
+    process.env['SANDCHEST_API_KEY'] = 'sk_from_env'
+    const client = new Sandchest()
+    expect(client).toBeInstanceOf(Sandchest)
+  })
+
+  test('options apiKey takes precedence over env var', () => {
+    process.env['SANDCHEST_API_KEY'] = 'sk_from_env'
+    const client = new Sandchest({ apiKey: 'sk_from_opts' })
+    // The HttpClient is created — we just verify no error thrown
+    expect(client._http).toBeDefined()
+  })
+
+  test('uses default base URL when not specified', () => {
+    const client = new Sandchest({ apiKey: 'sk_test' })
+    expect(client._http).toBeDefined()
+  })
+
+  test('accepts custom baseUrl, timeout, and retries', () => {
+    const client = new Sandchest({
+      apiKey: 'sk_test',
+      baseUrl: 'https://custom.api.com',
+      timeout: 5000,
+      retries: 1,
+    })
+    expect(client._http).toBeDefined()
+  })
+
+  test('create throws not implemented', async () => {
+    const client = new Sandchest({ apiKey: 'sk_test' })
+    await expect(client.create()).rejects.toThrow('Not implemented')
+  })
+
+  test('get throws not implemented', async () => {
+    const client = new Sandchest({ apiKey: 'sk_test' })
+    await expect(client.get('sb_abc')).rejects.toThrow('Not implemented')
+  })
+
+  test('list throws not implemented', async () => {
+    const client = new Sandchest({ apiKey: 'sk_test' })
+    await expect(client.list()).rejects.toThrow('Not implemented')
+  })
+})

packages/sdk-ts/src/client.test.ts

@@ -0,0 +1,116 @@
+import { describe, test, expect } from 'bun:test'
+import {
+  SandchestError,
+  NotFoundError,
+  RateLimitError,
+  SandboxNotRunningError,
+  ValidationError,
+  AuthenticationError,
+} from './errors.js'
+
+describe('SandchestError', () => {
+  test('stores code, status, requestId, and message', () => {
+    const err = new SandchestError({
+      code: 'internal_error',
+      message: 'Something went wrong',
+      status: 500,
+      requestId: 'req_abc123',
+    })
+
+    expect(err.code).toBe('internal_error')
+    expect(err.status).toBe(500)
+    expect(err.requestId).toBe('req_abc123')
+    expect(err.message).toBe('Something went wrong')
+    expect(err.name).toBe('SandchestError')
+  })
+
+  test('extends Error', () => {
+    const err = new SandchestError({
+      code: 'internal_error',
+      message: 'fail',
+      status: 500,
+      requestId: 'req_1',
+    })
+    expect(err).toBeInstanceOf(Error)
+  })
+})
+
+describe('NotFoundError', () => {
+  test('sets status 404 and code not_found', () => {
+    const err = new NotFoundError({ message: 'Sandbox not found', requestId: 'req_2' })
+    expect(err.status).toBe(404)
+    expect(err.code).toBe('not_found')
+    expect(err.name).toBe('NotFoundError')
+    expect(err.message).toBe('Sandbox not found')
+  })
+
+  test('is instanceof SandchestError', () => {
+    const err = new NotFoundError({ message: 'gone', requestId: 'req_3' })
+    expect(err).toBeInstanceOf(SandchestError)
+    expect(err).toBeInstanceOf(Error)
+  })
+})
+
+describe('RateLimitError', () => {
+  test('sets status 429, code rate_limited, and retryAfter', () => {
+    const err = new RateLimitError({
+      message: 'Too many requests',
+      requestId: 'req_4',
+      retryAfter: 30,
+    })
+    expect(err.status).toBe(429)
+    expect(err.code).toBe('rate_limited')
+    expect(err.name).toBe('RateLimitError')
+    expect(err.retryAfter).toBe(30)
+  })
+
+  test('is instanceof SandchestError', () => {
+    const err = new RateLimitError({ message: 'slow down', requestId: 'req_5', retryAfter: 1 })
+    expect(err).toBeInstanceOf(SandchestError)
+  })
+})
+
+describe('SandboxNotRunningError', () => {
+  test('sets status 409 and code sandbox_not_running', () => {
+    const err = new SandboxNotRunningError({
+      message: 'Sandbox is stopped',
+      requestId: 'req_6',
+    })
+    expect(err.status).toBe(409)
+    expect(err.code).toBe('sandbox_not_running')
+    expect(err.name).toBe('SandboxNotRunningError')
+  })
+
+  test('is instanceof SandchestError', () => {
+    const err = new SandboxNotRunningError({ message: 'not running', requestId: 'req_7' })
+    expect(err).toBeInstanceOf(SandchestError)
+  })
+})
+
+describe('ValidationError', () => {
+  test('sets status 400 and code validation_error', () => {
+    const err = new ValidationError({ message: 'Invalid body', requestId: 'req_8' })
+    expect(err.status).toBe(400)
+    expect(err.code).toBe('validation_error')
+    expect(err.name).toBe('ValidationError')
+  })
+
+  test('is instanceof SandchestError', () => {
+    const err = new ValidationError({ message: 'bad', requestId: 'req_9' })
+    expect(err).toBeInstanceOf(SandchestError)
+  })
+})
+
+describe('AuthenticationError', () => {
+  test('sets status 401 and code unauthorized', () => {
+    const err = new AuthenticationError({ message: 'Invalid API key', requestId: 'req_10' })
+    expect(err.status).toBe(401)
+    expect(err.code).toBe('unauthorized')
+    expect(err.name).toBe('AuthenticationError')
+  })
+
+  test('is instanceof SandchestError', () => {
+    const err = new AuthenticationError({ message: 'unauthed', requestId: 'req_11' })
+    expect(err).toBeInstanceOf(SandchestError)
+  })
+})