@operato/scene-storage 10.0.0-beta.41 → 10.0.0-beta.42

package/test/test-storage-rack-batched.ts

@@ -0,0 +1,606 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ *
+ * StorageRack batched mode behavioural tests — FakeBatchedRack 으로 contract 검증.
+ *
+ * 실제 storage-rack.ts import 는 @hatiolab/things-scene 번들의 Component named export
+ * 누락으로 mocha 환경에서 불가. 기존 test-storage-rack-crane.ts 와 동일하게 Fake 패턴.
+ *
+ * 검증하는 contract:
+ *   - 점유 cell materialize → carrier 자동 생성 + payload 에서 제거
+ *   - 빈 cell materialize → empty cell
+ *   - canReceive 가 자식 carrier 갯수 기반으로 정직히 동작
+ *   - dematerialize → record 복귀, 컴포넌트 정리
+ *   - cellComponent / carrierAt / cell.carrier 의 lookup 정확성
+ *   - patchStock 의 incremental update + state.data sync
+ *   - Mover.pickAndPlace 와의 통합 (Putaway / Pickup / Cell-to-cell)
+ *   - "박스 다시 끌고 나옴" 결함 회귀 방지
+ */
+
+import 'should'
+import { ContainerCapacity, TRANSFER_SLOT_KEY } from '@hatiolab/things-scene'
+import Mover from '../../scene-base/src/mover.js'
+
+// ── Fake infra (test-storage-rack-crane.ts 와 동일 baseline + on/off 이벤트) ──
+
+class FakeBase {
+  _components: any[] = []
+  state: Record<string, any>
+  parent: any = null
+  root: any = null
+  app: any = { isViewMode: true }
+  _listeners = new Map<string, Array<(...args: any[]) => void>>()
+
+  constructor(state: Record<string, any> = {}) {
+    this.state = state
+  }
+
+  get components() {
+    return this._components
+  }
+
+  setState(keyOrObj: string | Record<string, any>, value?: any) {
+    if (typeof keyOrObj === 'object') Object.assign(this.state, keyOrObj)
+    else this.state[keyOrObj as string] = value
+  }
+
+  getState(key: string) {
+    return this.state[key]
+  }
+
+  addComponent(child: any) {
+    if (child.parent && child.parent !== this) {
+      const idx = child.parent._components?.indexOf(child) ?? -1
+      if (idx >= 0) child.parent._components.splice(idx, 1)
+      child.parent = null
+    }
+    if (!this._components.includes(child)) this._components.push(child)
+    child.parent = this
+  }
+
+  removeComponent(child: any) {
+    const idx = this._components.indexOf(child)
+    if (idx >= 0) this._components.splice(idx, 1)
+    if (child.parent === this) child.parent = null
+  }
+
+  reparent(child: any, _options?: any) {
+    this.addComponent(child)
+  }
+
+  on(name: string, fn: (...args: any[]) => void) {
+    let list = this._listeners.get(name)
+    if (!list) { list = []; this._listeners.set(name, list) }
+    list.push(fn)
+  }
+  off(name: string, fn: (...args: any[]) => void) {
+    const list = this._listeners.get(name)
+    if (!list) return
+    const i = list.indexOf(fn)
+    if (i >= 0) list.splice(i, 1)
+  }
+  trigger(name: string, payload?: any) {
+    const list = this._listeners.get(name)
+    if (!list) return
+    for (const fn of [...list]) fn(payload)
+  }
+}
+
+// ── FakeCarrier — operation archetype 모방 ────────────────────────────────────
+
+function makeCarrier(state: any = { type: 'parcel' }) {
+  return {
+    parent: null as any,
+    state: { ...state },
+    [TRANSFER_SLOT_KEY]: undefined as any,
+    __rackRecord: undefined as any,
+    constructor: { placement: 'operation' },
+    setState(s: any) { Object.assign(this.state, s) }
+  }
+}
+
+// ── FakeRackCell — RackCell.receive/dispatch/canReceive 모방 + carrier getter ─
+
+class FakeRackCell extends FakeBase {
+  cellId: string
+
+  constructor(state: Record<string, any> = {}) {
+    super(state)
+    this.cellId = (state.cellId as string) || 'cell-0-0-0'
+  }
+
+  get carrier() {
+    return this._components.find((c: any) => c.constructor?.placement === 'operation')
+  }
+
+  canReceive(_component?: any): boolean {
+    return this._components.length < 1
+  }
+
+  async receive(carrier: any, options: any = {}): Promise<void> {
+    if (!this.canReceive(carrier)) {
+      this.trigger('transfer-rejected', { component: carrier, container: this })
+      return
+    }
+    carrier[TRANSFER_SLOT_KEY] = this.cellId
+    this.reparent(carrier, options)
+    this.trigger('transfer-received', { component: carrier, container: this, slotId: this.cellId })
+  }
+
+  async dispatch(carrier: any, target: any, options: any = {}): Promise<void> {
+    this.removeComponent(carrier)
+    if (typeof target?.receive === 'function') {
+      await target.receive(carrier, options)
+    } else {
+      target?.reparent?.(carrier, options)
+    }
+    this.trigger('transfer-dispatched', { component: carrier, container: this, target })
+  }
+}
+
+// ── FakeCrane — Mover + ContainerCapacity ─────────────────────────────────────
+
+const FakeCraneBase = Mover(ContainerCapacity(FakeBase as any))
+
+class FakeCrane extends (FakeCraneBase as any) {
+  constructor(state: Record<string, any> = {}) {
+    super({ status: 'idle', carriageHeight: 0, ...state })
+  }
+
+  get slots() { return [{ id: 'forks', maxCount: 1 }] }
+
+  moveTo() { return Promise.resolve() }
+
+  async engage(_target: any, kind: 'pick' | 'place') {
+    this.state.status = kind === 'pick' ? 'loading' : 'unloading'
+  }
+}
+
+// ── FakeBatchedRack — 실제 storage-rack.ts contract 와 일치하는 mock ──────────
+// 이 mock 의 동작이 *실제 코드의 의도된 contract*. 둘이 다르면 mock 또는 실제 둘 중
+// 하나가 틀린 것 — review 신호.
+
+interface CellDef {
+  id: string
+  bay: number
+  row: number
+  level: number
+  size: { width: number; height: number; depth: number }
+  localPosition: { x: number; y: number; z: number }
+}
+
+class FakeBatchedRack extends FakeBase {
+  bays: number
+  levels: number
+  _cellMap: { cells: CellDef[]; findById: (id: string) => CellDef | null }
+  _batchedPayload = new Map<string, any>()
+  _cellRegistry = new Map<string, FakeRackCell>()
+  _applyingData = false
+
+  constructor(bays: number, levels: number, data: any[] = []) {
+    super({ batched: true, data: [...data], bays, levels, width: 1000, height: 600, depth: 3000 })
+    this.bays = bays
+    this.levels = levels
+
+    const cells: CellDef[] = []
+    const bayWidth = 1000 / bays
+    const levelHeight = 3000 / levels
+    for (let bay = 0; bay < bays; bay++) {
+      for (let level = 0; level < levels; level++) {
+        cells.push({
+          id: `${bay}-0-${level}`,
+          bay: bay + 1, row: 1, level: level + 1,
+          size: { width: bayWidth, height: levelHeight, depth: 600 },
+          localPosition: { x: bay * bayWidth, y: level * levelHeight, z: 0 }
+        })
+      }
+    }
+    this._cellMap = {
+      cells,
+      findById: (id: string) => cells.find(c => c.id === id) ?? null
+    }
+
+    // initial payload 적재
+    for (const r of data) {
+      if (r?.cellId) this._batchedPayload.set(r.cellId, { ...r })
+    }
+  }
+
+  get cellMap() { return this._cellMap }
+
+  _resolveCellId(idOrBay: string | number, row: number, level: number): string {
+    return typeof idOrBay === 'string'
+      ? idOrBay
+      : `${(idOrBay as number) - 1}-${row - 1}-${level - 1}`
+  }
+
+  materializeCell(idOrBay: string | number, row = 1, level = 1): FakeRackCell | null {
+    const cellId = this._resolveCellId(idOrBay, row, level)
+    if (this._cellRegistry.has(cellId)) return this._cellRegistry.get(cellId)!
+    const def = this._cellMap.findById(cellId)
+    if (!def) return null
+
+    const cell = new FakeRackCell({ cellId })
+    cell.parent = this
+    this.addComponent(cell)
+    this._cellRegistry.set(cellId, cell)
+
+    const record = this._batchedPayload.get(cellId)
+    if (record) {
+      this._batchedPayload.delete(cellId)
+      const carrier = makeCarrier({ type: record.type || 'parcel', ...record })
+      carrier.__rackRecord = { ...record }
+      cell.addComponent(carrier)
+    }
+
+    // auto-cleanup on transfer-dispatched only (transfer-received → 유지)
+    const autoCleanup = () => queueMicrotask(() => this.dematerializeCell(cellId))
+    cell.on('transfer-dispatched', autoCleanup)
+    ;(cell as any).__rackAutoCleanup = autoCleanup
+    return cell
+  }
+
+  dematerializeCell(idOrBay: string | number, row = 1, level = 1): void {
+    const cellId = this._resolveCellId(idOrBay, row, level)
+    const cell = this._cellRegistry.get(cellId)
+    if (!cell) return
+
+    const carrier = cell._components.find((c: any) => c.constructor?.placement === 'operation')
+    if (carrier) {
+      const record = carrier.__rackRecord ?? { cellId, ...carrier.state }
+      this._batchedPayload.set(cellId, record)
+    }
+    const ac = (cell as any).__rackAutoCleanup
+    if (ac) cell.off('transfer-dispatched', ac)
+    this.removeComponent(cell)
+    this._cellRegistry.delete(cellId)
+  }
+
+  cellComponent(idOrBay: string | number, row = 1, level = 1): FakeRackCell | null {
+    const def = this._cellMap.findById(this._resolveCellId(idOrBay, row, level))
+    if (!def) return null
+    for (const c of this._components) {
+      if ((c as any).cellId === def.id) return c as FakeRackCell
+    }
+    if (this.state.batched) return this.materializeCell(idOrBay, row, level)
+    return null
+  }
+
+  carrierAt(idOrBay: string | number, row = 1, level = 1): any {
+    const cell = this.cellComponent(idOrBay, row, level)
+    return cell?.carrier ?? null
+  }
+
+  patchStock(cellId: string, fields: Record<string, any>) {
+    const existing = this._batchedPayload.get(cellId)
+    if (!existing) return
+    const merged = { ...existing, ...fields }
+    this._batchedPayload.set(cellId, merged)
+
+    // state.data 동기화 (rack 의 실제 로직 모방)
+    const data = (this.state.data as any[]) ?? []
+    const idx = data.findIndex(r => r?.cellId === cellId)
+    if (idx >= 0) data[idx] = merged
+    else data.push({ ...merged, cellId })
+  }
+}
+
+// ── Group 1: Batched payload 초기화 ─────────────────────────────────────────
+
+const sampleData = () => [
+  { cellId: '0-0-0', type: 'parcel', sku: 'SKU-A', status: 'occupied' },
+  { cellId: '1-0-0', type: 'parcel', sku: 'SKU-B', status: 'occupied' },
+  { cellId: '2-0-2', type: 'parcel', sku: 'SKU-C', status: 'reserved' }
+]
+
+describe('Rack batched: 초기 payload', () => {
+  it('cell 컴포넌트가 만들어지지 않음 (lazy)', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack._cellRegistry.size.should.equal(0)
+  })
+
+  it('초기 data 가 _batchedPayload 로 반영됨', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack._batchedPayload.size.should.equal(3)
+    rack._batchedPayload.has('0-0-0').should.be.true()
+    rack._batchedPayload.has('2-0-2').should.be.true()
+  })
+})
+
+// ── Group 2: materializeCell ────────────────────────────────────────────────
+
+describe('Rack batched: materializeCell', () => {
+  it('빈 cell materialize → cell.components.length = 0', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const cell = rack.materializeCell(4, 1, 4)!         // 3-0-3 — 빈 셀
+    cell.should.not.be.null()
+    cell._components.length.should.equal(0)
+  })
+
+  it('점유 cell materialize → carrier 자동 생성, length=1', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const cell = rack.materializeCell(1, 1, 1)!         // 0-0-0 — 점유
+    cell._components.length.should.equal(1)
+    cell._components[0].state.type.should.equal('parcel')
+    cell._components[0].state.sku.should.equal('SKU-A')
+  })
+
+  it('점유 cell materialize 후 canReceive=false', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const cell = rack.materializeCell(1, 1, 1)!
+    cell.canReceive(undefined).should.be.false()
+  })
+
+  it('빈 cell materialize 후 canReceive=true', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const cell = rack.materializeCell(4, 1, 4)!
+    cell.canReceive(undefined).should.be.true()
+  })
+
+  it('materialize idempotent', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const a = rack.materializeCell(1, 1, 1)
+    const b = rack.materializeCell(1, 1, 1)
+    a!.should.equal(b!)
+  })
+
+  it('materialize 시 payload 에서 cellId 제거', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack._batchedPayload.has('0-0-0').should.be.true()
+    rack.materializeCell(1, 1, 1)
+    rack._batchedPayload.has('0-0-0').should.be.false()
+  })
+
+  it('cellMap 에 없는 cellId → null', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    ;(rack.materializeCell(99, 99, 99) === null).should.be.true()
+  })
+})
+
+// ── Group 3: dematerializeCell ──────────────────────────────────────────────
+
+describe('Rack batched: dematerializeCell', () => {
+  it('점유 cell dematerialize → record 가 payload 로 복귀', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack.materializeCell(1, 1, 1)
+    rack.dematerializeCell(1, 1, 1)
+    rack._batchedPayload.has('0-0-0').should.be.true()
+  })
+
+  it('dematerialize 후 cell 컴포넌트 제거', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack.materializeCell(1, 1, 1)
+    rack._cellRegistry.has('0-0-0').should.be.true()
+    rack.dematerializeCell(1, 1, 1)
+    rack._cellRegistry.has('0-0-0').should.be.false()
+  })
+})
+
+// ── Group 4: cellComponent / carrierAt ─────────────────────────────────────
+
+describe('Rack batched: cellComponent / carrierAt', () => {
+  it('cellComponent 호출 시 batched 면 자동 materialize', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack._cellRegistry.size.should.equal(0)
+    rack.cellComponent(1, 1, 1)
+    rack._cellRegistry.size.should.equal(1)
+  })
+
+  it('carrierAt 으로 점유 cell 의 carrier 직접 추출', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const carrier = rack.carrierAt(1, 1, 1)
+    carrier.should.not.be.null()
+    carrier.state.type.should.equal('parcel')
+  })
+
+  it('carrierAt 빈 cell → null', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    ;(rack.carrierAt(4, 1, 4) === null).should.be.true()
+  })
+
+  it('cell.carrier getter', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const cell = rack.cellComponent(1, 1, 1)!
+    cell.carrier.should.not.be.null()
+    cell.carrier.state.type.should.equal('parcel')
+  })
+})
+
+// ── Group 5: patchStock ────────────────────────────────────────────────────
+
+describe('Rack batched: patchStock', () => {
+  it('payload 의 record 갱신', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack.patchStock('0-0-0', { status: 'damaged', qty: 7 })
+    const r = rack._batchedPayload.get('0-0-0')
+    r.status.should.equal('damaged')
+    r.qty.should.equal(7)
+  })
+
+  it('state.data 도 함께 갱신', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    rack.patchStock('0-0-0', { status: 'reserved' })
+    const data = rack.state.data as any[]
+    const r = data.find(x => x.cellId === '0-0-0')
+    r.status.should.equal('reserved')
+  })
+
+  it('payload 에 없는 cell patch → no-op', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const before = rack._batchedPayload.size
+    rack.patchStock('4-0-4', { status: 'reserved' })
+    rack._batchedPayload.size.should.equal(before)
+  })
+})
+
+// ── Group 6: Mover 통합 — Putaway / Pickup / Move ──────────────────────────
+
+describe('Rack batched + Crane: Putaway (외부 → 빈 cell)', () => {
+  it('외부 parcel → 빈 cell. 성공 후 cell.components.length=1', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const crane = new FakeCrane()
+    const parcel = makeCarrier({ type: 'parcel', sku: 'NEW' })
+
+    const targetCell = rack.cellComponent(4, 1, 4)!  // 빈 cell
+    await crane.pickAndPlace(parcel, targetCell)
+
+    targetCell._components.length.should.equal(1)
+    targetCell._components[0].should.equal(parcel)
+  })
+
+  it('putaway 후 parcel 이 cell 에서 *제거되지 않음* (회귀: 박스 다시 끌고 나옴)', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const crane = new FakeCrane()
+    const parcel = makeCarrier({ type: 'parcel', sku: 'NEW' })
+
+    const targetCell = rack.cellComponent(4, 1, 4)!
+    await crane.pickAndPlace(parcel, targetCell)
+
+    // queueMicrotask 가 flush 되도록 한 tick 대기
+    await new Promise(r => setImmediate(r))
+
+    // 회귀 검증 — auto-cleanup 이 transfer-received 에 걸리면 안 됨
+    rack._cellRegistry.has('3-0-3').should.be.true()
+    targetCell._components.length.should.equal(1)
+    targetCell._components[0].should.equal(parcel)
+  })
+})
+
+describe('Rack batched: 점유 cell 의 canReceive', () => {
+  it('점유 cell.canReceive 는 false (회귀: 이미 점유된 cell 에 putaway 통과)', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const targetCell = rack.cellComponent(1, 1, 1)!
+    targetCell._components.length.should.equal(1)
+    targetCell.canReceive(undefined).should.be.false()
+  })
+
+  it('빈 cell.canReceive 는 true', () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const targetCell = rack.cellComponent(4, 1, 4)!
+    targetCell.canReceive(undefined).should.be.true()
+  })
+
+  it('점유 cell 에 직접 receive 호출 → reject (transfer-rejected 발생)', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const targetCell = rack.cellComponent(1, 1, 1)!
+    const intruder = makeCarrier({ type: 'parcel', sku: 'INTRUDER' })
+
+    let rejected = false
+    targetCell.on('transfer-rejected', () => { rejected = true })
+    await targetCell.receive(intruder)
+
+    rejected.should.be.true()
+    targetCell._components.length.should.equal(1)
+    targetCell._components[0].state.sku.should.equal('SKU-A')   // 원래 점유자
+  })
+})
+
+describe('Rack batched: auto-dematerialize on transfer-dispatched', () => {
+  it('transfer-dispatched 발사 → microtask 후 source cell 정리', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const sourceCell = rack.cellComponent(1, 1, 1)!
+    rack._cellRegistry.has('0-0-0').should.be.true()
+
+    // dispatch 시뮬레이션 — 실제로는 Mover/Transfer 가 호출
+    const carrier = sourceCell.carrier
+    sourceCell.removeComponent(carrier)
+    sourceCell.trigger('transfer-dispatched', { component: carrier, container: sourceCell })
+
+    await new Promise(r => setImmediate(r))
+    rack._cellRegistry.has('0-0-0').should.be.false('pickup 후 source cell 자동 정리')
+  })
+
+  it('transfer-received 발사 → cell *유지* (회귀: 박스 다시 끌고 나옴 방지)', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const targetCell = rack.cellComponent(4, 1, 4)!   // 빈 cell
+    const incomingParcel = makeCarrier({ type: 'parcel', sku: 'NEW' })
+
+    await targetCell.receive(incomingParcel)
+    await new Promise(r => setImmediate(r))
+
+    rack._cellRegistry.has('3-0-3').should.be.true('putaway 후 target cell 유지')
+    targetCell._components.length.should.equal(1)
+    targetCell._components[0].should.equal(incomingParcel)
+  })
+})
+
+describe('Rack batched + Crane: Pickup (cell → 외부)', () => {
+  it('점유 cell 에서 carrier 추출 후 다른 holder 로', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const crane = new FakeCrane()
+    const externalSpot = new FakeRackCell({ cellId: 'spot-1' })
+
+    const sourceCell = rack.cellComponent(1, 1, 1)!
+    const carrier = sourceCell.carrier
+    carrier.should.not.be.null()
+
+    await crane.pickAndPlace(carrier, externalSpot)
+
+    externalSpot._components.length.should.equal(1)
+    externalSpot._components[0].should.equal(carrier)
+    sourceCell._components.length.should.equal(0)
+  })
+})
+
+describe('Rack batched + Crane: Cell-to-cell move (sub-step)', () => {
+  it('source.carrier 추출 → 다른 cell 로 place 성공', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const crane = new FakeCrane()
+
+    const source = rack.cellComponent(1, 1, 1)!
+    const target = rack.cellComponent(4, 1, 4)!
+    const carrier = source.carrier
+
+    await crane.pickAndPlace(carrier, target)
+
+    target._components.length.should.equal(1)
+    target._components[0].should.equal(carrier)
+    rack._cellRegistry.has('3-0-3').should.be.true('target cell 은 유지')
+  })
+})
+
+// ── Group 7: 신규 결함 — pick 도중 텔레포트 ────────────────────────────────────
+//
+// 사용자 보고: "크레인이 대상 아이템을 가지러 가는 도중에 텔레포트되어서 크레인
+// 캐리지에 옮겨져있는 경우가 많다. 이 시점에 크레인은 운행을 멈춰버린다."
+//
+// 검증 contract:
+//   - pick 의 moveTo 단계 동안 carrier 가 source cell 의 child 여야 함 (이동 X)
+//   - moveTo 완료 후에야 reparent 가 일어남
+//   - 중간에 reparent 가 발동되면 crane 의 동선이 깨질 위험
+
+describe('Rack batched + Crane: pick 도중 텔레포트 회귀 방지', () => {
+  it('moveTo 단계 동안 carrier.parent === sourceCell (premature reparent 없음)', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const sourceCell = rack.cellComponent(1, 1, 1)!
+    const carrier = sourceCell.carrier
+
+    // 동선 추적용 crane — moveTo 중간에 carrier.parent 가 무엇인지 기록
+    class TracingCrane extends FakeCrane {
+      midMoveParent: any = null
+      async moveTo(_t: any) {
+        // 중간 tick 시점에 carrier 의 parent 캡처
+        this.midMoveParent = carrier.parent
+        await Promise.resolve()
+      }
+    }
+    const crane = new TracingCrane()
+    await crane.pick(carrier)
+
+    // 검증: moveTo 중에 carrier 는 아직 source cell 의 child 였어야 함
+    crane.midMoveParent.should.equal(sourceCell, 'moveTo 단계에서 carrier 가 텔레포트되면 안 됨')
+  })
+
+  it('pick 완료 후 carrier.parent === crane (reparent 는 moveTo+engage 뒤)', async () => {
+    const rack = new FakeBatchedRack(5, 4, sampleData())
+    const crane = new FakeCrane()
+
+    const sourceCell = rack.cellComponent(1, 1, 1)!
+    const carrier = sourceCell.carrier
+
+    await crane.pick(carrier)
+
+    carrier.parent.should.equal(crane, 'pick 완료 시 crane 의 child')
+    sourceCell._components.length.should.equal(0)
+  })
+})