@gravito/launchpad 0.1.0

package/tests/Deployment.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { PayloadInjector } from '../src/Application/PayloadInjector'
+import { PoolManager } from '../src/Application/PoolManager'
+import { Mission } from '../src/Domain/Mission'
+import { RocketStatus } from '../src/Domain/RocketStatus'
+
+describe('Payload Injection Flow', () => {
+  // Mocks
+  const mockDocker: any = {
+    createBaseContainer: mock(() => Promise.resolve('cid-1')),
+    copyFiles: mock(() => Promise.resolve()),
+    executeCommand: mock(() => Promise.resolve({ exitCode: 0, stdout: '', stderr: '' })),
+    removeContainer: mock(() => Promise.resolve()),
+  }
+
+  const mockGit: any = {
+    clone: mock(() => Promise.resolve('/tmp/mock-code')),
+  }
+
+  const mockRepo: any = {
+    save: mock(() => Promise.resolve()),
+    findIdle: mock(() => Promise.resolve(null)), // Force create
+    findAll: mock(() => Promise.resolve([])),
+  }
+
+  const pool = new PoolManager(mockDocker, mockRepo)
+  const injector = new PayloadInjector(mockDocker, mockGit)
+
+  it('應該能從指派任務到成功點火', async () => {
+    // 1. Assign
+    const mission = Mission.create({
+      id: 'pr-2',
+      repoUrl: 'http://git',
+      branch: 'dev',
+      commitSha: 'sha',
+    })
+    const rocket = await pool.assignMission(mission)
+
+    expect(rocket.status).toBe(RocketStatus.PREPARING)
+
+    // 2. Deploy
+    await injector.deploy(rocket)
+
+    expect(mockGit.clone).toHaveBeenCalled()
+    expect(mockDocker.copyFiles).toHaveBeenCalled()
+    expect(mockDocker.executeCommand).toHaveBeenCalled() // bun install
+
+    expect(rocket.status).toBe(RocketStatus.ORBITING)
+  })
+})

package/tests/Integration.test.ts

@@ -0,0 +1,42 @@
+import { afterAll, describe, expect, it } from 'bun:test'
+import { PoolManager } from '../src/Application/PoolManager'
+import { DockerAdapter } from '../src/Infrastructure/Docker/DockerAdapter'
+import { InMemoryRocketRepository } from '../src/Infrastructure/Persistence/InMemoryRocketRepository'
+
+describe('LaunchPad 集成測試 (真實 Docker)', () => {
+  const docker = new DockerAdapter()
+  const repo = new InMemoryRocketRepository()
+  const manager = new PoolManager(docker, repo)
+
+  afterAll(async () => {
+    // 清理測試建立的容器
+    const rockets = await repo.findAll()
+    for (const rocket of rockets) {
+      await docker.removeContainer(rocket.containerId)
+    }
+  })
+
+  it('應該能成功熱機並在容器內執行指令', async () => {
+    try {
+      // 1. Warmup
+      await manager.warmup(1)
+      const rockets = await repo.findAll()
+      expect(rockets.length).toBe(1)
+
+      const rocket = rockets[0]
+      expect(rocket.containerId).toBeDefined()
+
+      // 2. 測試指令執行
+      const result = await docker.executeCommand(rocket.containerId, ['bun', '--version'])
+      console.log(`[Test] 容器內 Bun 版本: ${result.stdout.trim()}`)
+      expect(result.exitCode).toBe(0)
+      expect(result.stdout).toContain('1.') // 應該是 1.x 版本
+    } catch (e: any) {
+      if (e.message.includes('docker') || e.message.includes('ENOENT')) {
+        console.warn('⚠️  跳過測試：本地環境未偵測到 Docker Daemon')
+        return
+      }
+      throw e
+    }
+  })
+})

package/tests/PoolManager.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { PoolManager } from '../src/Application/PoolManager'
+import { Mission } from '../src/Domain/Mission'
+import { RocketStatus } from '../src/Domain/RocketStatus'
+
+describe('PoolManager (Application Service)', () => {
+  // Mock Docker Adapter
+  const mockDocker: any = {
+    createBaseContainer: mock(() => Promise.resolve('container-id-123')),
+    removeContainer: mock(() => Promise.resolve()),
+  }
+
+  // Simple In-memory Repository Mock
+  const rockets: any[] = []
+  const mockRepo: any = {
+    save: mock((r) => {
+      const idx = rockets.findIndex((x) => x.id === r.id)
+      if (idx >= 0) {
+        rockets[idx] = r
+      } else {
+        rockets.push(r)
+      }
+      return Promise.resolve()
+    }),
+    findAll: mock(() => Promise.resolve(rockets)),
+    findIdle: mock(() =>
+      Promise.resolve(rockets.find((r) => r.status === RocketStatus.IDLE) || null)
+    ),
+  }
+
+  const manager = new PoolManager(mockDocker, mockRepo)
+
+  it('應該能正確熱機並指派任務', async () => {
+    // Warmup
+    await manager.warmup(2)
+    expect(rockets.length).toBe(2)
+    expect(mockDocker.createBaseContainer).toHaveBeenCalledTimes(2)
+
+    // Assign Mission
+    const mission = Mission.create({
+      id: 'pr-1',
+      repoUrl: 'url',
+      branch: 'b',
+      commitSha: 's',
+    })
+
+    const assignedRocket = await manager.assignMission(mission)
+    expect(assignedRocket.status).toBe(RocketStatus.PREPARING)
+    expect(assignedRocket.currentMission?.id).toBe('pr-1')
+
+    // Ignite before recycle (Must be ORBITING to splashDown)
+    assignedRocket.ignite()
+    expect(assignedRocket.status).toBe(RocketStatus.ORBITING)
+
+    // Recycle
+    await manager.recycle('pr-1')
+    expect(assignedRocket.status).toBe(RocketStatus.IDLE)
+    expect(assignedRocket.currentMission).toBeNull()
+  })
+})

package/tests/Refurbishment.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { RefurbishUnit } from '../src/Application/RefurbishUnit'
+import { Mission } from '../src/Domain/Mission'
+import { Rocket } from '../src/Domain/Rocket'
+import { RocketStatus } from '../src/Domain/RocketStatus'
+
+describe('RefurbishUnit (Rocket Recovery)', () => {
+  it('應該能執行深度清理並將火箭重置為 IDLE', async () => {
+    // 1. Setup
+    const mockDocker: any = {
+      executeCommand: mock(() => Promise.resolve({ exitCode: 0, stdout: '', stderr: '' })),
+    }
+    const unit = new RefurbishUnit(mockDocker)
+    const rocket = new Rocket('r1', 'c1')
+
+    // 模擬火箭正在運行
+    rocket.assignMission(Mission.create({ id: 'pr-1', repoUrl: 'u', branch: 'b', commitSha: 's' }))
+    rocket.ignite()
+    expect(rocket.status).toBe(RocketStatus.ORBITING)
+
+    // 2. Execute Refurbish
+    await unit.refurbish(rocket)
+
+    // 3. Verify
+    expect(mockDocker.executeCommand).toHaveBeenCalled()
+    expect(rocket.status).toBe(RocketStatus.IDLE)
+    expect(rocket.currentMission).toBeNull()
+  })
+
+  it('如果清理失敗應該將火箭除役', async () => {
+    const mockDocker: any = {
+      executeCommand: mock(() => Promise.resolve({ exitCode: 1, stdout: '', stderr: 'Disk Full' })),
+    }
+    const unit = new RefurbishUnit(mockDocker)
+    const rocket = new Rocket('r2', 'c2')
+    rocket.assignMission(Mission.create({ id: 'pr-2', repoUrl: 'u', branch: 'b', commitSha: 's' }))
+    rocket.ignite()
+
+    await unit.refurbish(rocket)
+
+    expect(rocket.status).toBe(RocketStatus.DECOMMISSIONED)
+  })
+})

package/tests/Rocket.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  MissionAssigned,
+  RefurbishmentCompleted,
+  RocketIgnited,
+  RocketSplashedDown,
+} from '../src/Domain/Events'
+import { Mission } from '../src/Domain/Mission'
+import { Rocket } from '../src/Domain/Rocket'
+import { RocketStatus } from '../src/Domain/RocketStatus'
+
+describe('Rocket', () => {
+  test('transitions through mission lifecycle and emits events', () => {
+    const mission = Mission.create({
+      id: 'mission-1',
+      repoUrl: 'https://example.com/repo.git',
+      branch: 'main',
+      commitSha: 'abc123',
+    })
+    const rocket = new Rocket('rocket-1', 'container-1')
+
+    rocket.assignMission(mission)
+    expect(rocket.status).toBe(RocketStatus.PREPARING)
+    expect(rocket.currentMission).toBe(mission)
+    expect(rocket.pullDomainEvents()[0]).toBeInstanceOf(MissionAssigned)
+
+    rocket.ignite()
+    expect(rocket.status).toBe(RocketStatus.ORBITING)
+    expect(rocket.pullDomainEvents()[0]).toBeInstanceOf(RocketIgnited)
+
+    rocket.splashDown()
+    expect(rocket.status).toBe(RocketStatus.REFURBISHING)
+    expect(rocket.pullDomainEvents()[0]).toBeInstanceOf(RocketSplashedDown)
+
+    rocket.finishRefurbishment()
+    expect(rocket.status).toBe(RocketStatus.IDLE)
+    expect(rocket.currentMission).toBeNull()
+    expect(rocket.pullDomainEvents()[0]).toBeInstanceOf(RefurbishmentCompleted)
+  })
+
+  test('guards invalid transitions', () => {
+    const rocket = new Rocket('rocket-2', 'container-2')
+
+    expect(() => rocket.ignite()).toThrow()
+    expect(() => rocket.splashDown()).toThrow()
+    rocket.decommission()
+    expect(rocket.status).toBe(RocketStatus.DECOMMISSIONED)
+  })
+})

package/tests/Telemetry.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it, mock } from 'bun:test'
+import { MissionControl } from '../src/Application/MissionControl'
+import { Mission } from '../src/Domain/Mission'
+
+describe('MissionControl Telemetry', () => {
+  it('發射時應該能正確啟動日誌串流與效能監控', async () => {
+    const mockRocket = {
+      id: 'r1',
+      containerId: 'c1',
+      status: 'PREPARING',
+      assignDomain: mock(() => {}),
+      assignMission: mock(() => {}),
+      ignite: mock(() => {}),
+    }
+
+    const mockPool: any = {
+      assignMission: mock(() => Promise.resolve(mockRocket)),
+    }
+
+    const mockInjector: any = {
+      deploy: mock(() => Promise.resolve()),
+    }
+
+    const mockDocker: any = {
+      getExposedPort: mock(() => Promise.resolve(3000)),
+      streamLogs: mock((_id, cb) => {
+        cb('hello world') // 模擬一條日誌
+      }),
+      getStats: mock(() => Promise.resolve({ cpu: '10%', memory: '100MB' })),
+    }
+
+    const ctrl = new MissionControl(mockPool, mockInjector, mockDocker)
+    const telemetryLogs: any[] = []
+
+    await ctrl.launch(
+      Mission.create({ id: 'pr-1', repoUrl: 'url', branch: 'b', commitSha: 's' }),
+      (type, data) => telemetryLogs.push({ type, data })
+    )
+
+    expect(mockPool.assignMission).toHaveBeenCalled()
+    expect(mockInjector.deploy).toHaveBeenCalled()
+    expect(mockDocker.streamLogs).toHaveBeenCalledWith('c1', expect.any(Function))
+
+    // 驗證是否收到模擬日誌
+    expect(telemetryLogs).toContainEqual({
+      type: 'log',
+      data: { rocketId: 'r1', text: 'hello world' },
+    })
+  })
+})

package/tests/docker-adapter.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from 'bun:test'
+import { DockerAdapter } from '../src/Infrastructure/Docker/DockerAdapter'
+
+const makeStream = (text: string) => new Response(text).body as ReadableStream
+
+function makeProcess(stdoutText: string, stderrText: string, exitCode = 0) {
+  return {
+    stdout: makeStream(stdoutText),
+    stderr: makeStream(stderrText),
+    exitCode,
+    exited: Promise.resolve(),
+  }
+}
+
+describe('DockerAdapter', () => {
+  test('creates base container when stdout has container id', async () => {
+    const adapter = new DockerAdapter()
+    const originalSpawn = Bun.spawn
+    const containerId = 'a'.repeat(64)
+
+    Bun.spawn = () => makeProcess(containerId, '', 1) as any
+
+    try {
+      const result = await adapter.createBaseContainer()
+      expect(result).toBe(containerId)
+    } finally {
+      Bun.spawn = originalSpawn
+    }
+  })
+
+  test('throws when container creation fails', async () => {
+    const adapter = new DockerAdapter()
+    const originalSpawn = Bun.spawn
+
+    Bun.spawn = () => makeProcess('bad', 'boom', 1) as any
+
+    try {
+      await expect(adapter.createBaseContainer()).rejects.toThrow('boom')
+    } finally {
+      Bun.spawn = originalSpawn
+    }
+  })
+
+  test('copyFiles throws on non-zero exit code', async () => {
+    const adapter = new DockerAdapter()
+    const originalSpawn = Bun.spawn
+
+    Bun.spawn = () => makeProcess('', 'copy failed', 1) as any
+
+    try {
+      await expect(adapter.copyFiles('cid', '/src', '/target')).rejects.toThrow('copy failed')
+    } finally {
+      Bun.spawn = originalSpawn
+    }
+  })
+
+  test('executeCommand returns stdout and stderr', async () => {
+    const adapter = new DockerAdapter()
+    const originalSpawn = Bun.spawn
+
+    Bun.spawn = () => makeProcess('ok', 'warn', 0) as any
+
+    try {
+      const result = await adapter.executeCommand('cid', ['echo', 'ok'])
+      expect(result.stdout).toBe('ok')
+      expect(result.stderr).toBe('warn')
+      expect(result.exitCode).toBe(0)
+    } finally {
+      Bun.spawn = originalSpawn
+    }
+  })
+
+  test('getStats parses cpu and memory output', async () => {
+    const adapter = new DockerAdapter()
+    const originalSpawn = Bun.spawn
+
+    Bun.spawn = () => makeProcess('12%,10MiB / 20MiB', '', 0) as any
+
+    try {
+      const stats = await adapter.getStats('cid')
+      expect(stats.cpu).toBe('12%')
+      expect(stats.memory).toBe('10MiB / 20MiB')
+    } finally {
+      Bun.spawn = originalSpawn
+    }
+  })
+
+  test('streamLogs forwards stdout and stderr', async () => {
+    const adapter = new DockerAdapter()
+    const originalSpawn = Bun.spawn
+
+    Bun.spawn = () =>
+      ({
+        stdout: makeStream('out'),
+        stderr: makeStream('err'),
+        exited: Promise.resolve(),
+      }) as any
+
+    try {
+      const logs: string[] = []
+      adapter.streamLogs('cid', (data) => logs.push(data))
+
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      expect(logs.join('')).toContain('out')
+      expect(logs.join('')).toContain('err')
+    } finally {
+      Bun.spawn = originalSpawn
+    }
+  })
+})

package/tests/enterprise-coverage.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  AggregateRoot,
+  Command,
+  DomainEvent,
+  Entity,
+  Query,
+  UseCase,
+  ValueObject,
+} from '@gravito/enterprise'
+
+class ExampleEntity extends Entity<string> {}
+class ExampleValue extends ValueObject<{ value: string }> {}
+class ExampleEvent extends DomainEvent {}
+
+class ExampleAggregate extends AggregateRoot<string> {
+  record(event: DomainEvent) {
+    this.addDomainEvent(event)
+  }
+}
+
+class ExampleCommand extends Command {
+  constructor(public readonly name: string) {
+    super()
+  }
+}
+
+class ExampleQuery extends Query {
+  constructor(public readonly id: string) {
+    super()
+  }
+}
+
+class ExampleUseCase extends UseCase<string, string> {
+  execute(input: string): string {
+    return input.toUpperCase()
+  }
+}
+
+describe('Launchpad enterprise coverage', () => {
+  test('covers core enterprise primitives', () => {
+    const entity = new ExampleEntity('1')
+    const same = new ExampleEntity('1')
+    expect(entity.equals(same)).toBe(true)
+
+    const value = new ExampleValue({ value: 'a' })
+    const valueSame = new ExampleValue({ value: 'a' })
+    expect(value.equals(valueSame)).toBe(true)
+
+    const agg = new ExampleAggregate('agg-1')
+    agg.record(new ExampleEvent())
+    expect(agg.pullDomainEvents().length).toBe(1)
+
+    const cmd = new ExampleCommand('go')
+    const query = new ExampleQuery('q1')
+    expect(cmd.name).toBe('go')
+    expect(query.id).toBe('q1')
+
+    const useCase = new ExampleUseCase()
+    expect(useCase.execute('ok')).toBe('OK')
+  })
+})

package/tests/mission-control.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, mock, test } from 'bun:test'
+import { MissionControl } from '../src/Application/MissionControl'
+import { Mission } from '../src/Domain/Mission'
+
+function createRocket() {
+  return {
+    id: 'rocket-telemetry',
+    containerId: 'container-telemetry',
+    status: 'ORBITING',
+    assignDomain: mock(() => {}),
+  }
+}
+
+describe('MissionControl timers', () => {
+  test('emits stats and schedules recycle', async () => {
+    const rocket = createRocket()
+    const mission = Mission.create({
+      id: 'mission-telemetry',
+      repoUrl: 'https://example.com/repo.git',
+      branch: 'main',
+      commitSha: 'abc',
+    })
+
+    const poolManager = {
+      assignMission: async () => rocket,
+      recycle: mock(async () => {}),
+    }
+    const injector = {
+      deploy: mock(async () => {}),
+    }
+    const docker = {
+      streamLogs: mock(() => {}),
+      getStats: mock(async () => ({ cpu: '5%', memory: '10MB' })),
+      getExposedPort: mock(async () => 3000),
+    }
+
+    const originalSetInterval = global.setInterval
+    const originalSetTimeout = global.setTimeout
+    const originalClearInterval = global.clearInterval
+
+    let intervalFn: (() => Promise<void>) | null = null
+    const clearIntervalMock = mock(() => {})
+    let timeoutPromise: Promise<void> | null = null
+
+    global.setInterval = ((fn: () => Promise<void>) => {
+      intervalFn = fn
+      return 123 as any
+    }) as any
+
+    global.clearInterval = clearIntervalMock as any
+
+    global.setTimeout = ((fn: () => Promise<void>) => {
+      timeoutPromise = Promise.resolve(fn())
+      return 456 as any
+    }) as any
+
+    const mc = new MissionControl(poolManager as any, injector as any, docker as any)
+    const onTelemetry = mock(() => {})
+
+    try {
+      await mc.launch(mission, onTelemetry)
+
+      expect(intervalFn).not.toBeNull()
+      await intervalFn?.()
+      expect(docker.getStats).toHaveBeenCalledWith(rocket.containerId)
+
+      rocket.status = 'IDLE'
+      await intervalFn?.()
+      expect(clearIntervalMock).toHaveBeenCalled()
+
+      await timeoutPromise
+      expect(poolManager.recycle).toHaveBeenCalledWith('mission-telemetry')
+    } finally {
+      global.setInterval = originalSetInterval
+      global.setTimeout = originalSetTimeout
+      global.clearInterval = originalClearInterval
+    }
+  })
+})

package/tests/mission.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'bun:test'
+import { Mission } from '../src/Domain/Mission'
+
+describe('Mission', () => {
+  test('exposes mission properties', () => {
+    const mission = Mission.create({
+      id: 'm1',
+      repoUrl: 'https://example.com/repo.git',
+      branch: 'main',
+      commitSha: 'abc123',
+    })
+
+    expect(mission.id).toBe('m1')
+    expect(mission.repoUrl).toBe('https://example.com/repo.git')
+    expect(mission.branch).toBe('main')
+    expect(mission.commitSha).toBe('abc123')
+  })
+})

package/tests/payload-injector.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'bun:test'
+import { PayloadInjector } from '../src/Application/PayloadInjector'
+import { Mission } from '../src/Domain/Mission'
+import { Rocket } from '../src/Domain/Rocket'
+import { RocketStatus } from '../src/Domain/RocketStatus'
+
+class FakeGit {
+  cloned: Array<{ repoUrl: string; branch: string }> = []
+  async clone(repoUrl: string, branch: string): Promise<string> {
+    this.cloned.push({ repoUrl, branch })
+    return '/tmp/fake-repo'
+  }
+}
+
+class FakeDocker {
+  copyCalls: Array<{ containerId: string; source: string; target: string }> = []
+  commands: string[][] = []
+
+  async copyFiles(containerId: string, source: string, target: string): Promise<void> {
+    this.copyCalls.push({ containerId, source, target })
+  }
+
+  async executeCommand(containerId: string, command: string[]) {
+    this.commands.push([containerId, ...command])
+    return { stdout: '', stderr: '', exitCode: 0 }
+  }
+}
+
+describe('PayloadInjector', () => {
+  test('throws when rocket has no mission', async () => {
+    const docker = new FakeDocker()
+    const git = new FakeGit()
+    const injector = new PayloadInjector(docker as any, git as any)
+    const rocket = new Rocket('rocket-9', 'container-9')
+
+    await expect(injector.deploy(rocket)).rejects.toThrow('沒有指派任務')
+  })
+
+  test('deploys payload and ignites rocket', async () => {
+    const docker = new FakeDocker()
+    const git = new FakeGit()
+    const injector = new PayloadInjector(docker as any, git as any)
+
+    const rocket = new Rocket('rocket-10', 'container-10')
+    const mission = Mission.create({
+      id: 'mission-10',
+      repoUrl: 'https://example.com/repo.git',
+      branch: 'main',
+      commitSha: 'abc123',
+    })
+    rocket.assignMission(mission)
+
+    await injector.deploy(rocket)
+
+    expect(git.cloned[0]).toEqual({ repoUrl: mission.repoUrl, branch: mission.branch })
+    expect(docker.copyCalls[0]).toEqual({
+      containerId: rocket.containerId,
+      source: '/tmp/fake-repo',
+      target: '/app',
+    })
+    expect(docker.commands.length).toBeGreaterThanOrEqual(4)
+    expect(rocket.status).toBe(RocketStatus.ORBITING)
+  })
+})