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

package/test/test-rack-grid-cell.ts

@@ -0,0 +1,318 @@
+/*
+ * RackGridCell + RackGrid hybrid integration tests.
+ *
+ * 검증 대상:
+ *  - cell-component 가 있을 때 locationOf / cellIdOfLocation 이 *cell.state* lookup
+ *  - cellOverrides fallback 도 여전히 동작 (cell-component 없는 경우)
+ *  - setIsEmpty 가 cell-component 우선 mutate
+ *  - increaseLocation 이 cell-component 우선 mutate + cellOverrides 비손상
+ *  - cell.state.shelfLocations 가 RackGrid 의 shelfLocations 보다 우선
+ *
+ * 진짜 RackGrid/RackGridCell 인스턴스화는 things-scene 의존성으로 비현실적. 따라서
+ * MiniGridWithCells — RackGrid 의 알고리즘 + cell-component 들의 state 시뮬.
+ */
+
+import 'should'
+
+interface FakeCellState {
+  type: string
+  cellId?: string
+  section?: string
+  unit?: string
+  shelfLocations?: string
+  isEmpty?: boolean
+  border?: any
+}
+
+class FakeCell {
+  state: FakeCellState
+  constructor(initial: FakeCellState) {
+    this.state = { type: 'rack-grid-cell', ...initial }
+  }
+  set(key: any, value?: any) {
+    if (typeof key === 'string') {
+      if (value === null) delete (this.state as any)[key]
+      else (this.state as any)[key] = value
+    } else {
+      Object.assign(this.state, key)
+    }
+  }
+  getState(key: string) { return (this.state as any)[key] }
+}
+
+class MiniGridWithCells {
+  state: any
+  components: FakeCell[] = []
+  private _locationIndexCache?: Map<string, string>
+
+  constructor(initialState: any = {}, opts: { withCells?: boolean } = {}) {
+    this.state = {
+      columns: 4,
+      rows: 1,
+      shelves: 4,
+      sectionDigits: 2,
+      unitDigits: 2,
+      locPattern: '{z}{s}-{u}-{sh}',
+      zone: 'Z',
+      cellOverrides: {},
+      ...initialState
+    }
+    if (opts.withCells !== false) this._buildCells()
+  }
+
+  setState(partial: any) {
+    this.state = { ...this.state, ...partial }
+    this._locationIndexCache = undefined
+  }
+
+  invalidateLocationIndex() { this._locationIndexCache = undefined }
+
+  get columns(): number { return this.state.columns ?? 4 }
+  get rackRows(): number { return this.state.rows ?? 1 }
+  get shelves(): number { return this.state.shelves ?? 4 }
+  get cellOverrides() { return this.state.cellOverrides ?? {} }
+
+  private _buildCells() {
+    const cols = this.columns
+    const rows = this.rackRows
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        this.components.push(new FakeCell({ type: 'rack-grid-cell', cellId: `${c}-${r}` }))
+      }
+    }
+  }
+
+  cellAt(col: number, row: number = 0): FakeCell | null {
+    const idx = row * this.columns + col
+    return this.components[idx] ?? null
+  }
+
+  cellAtBayKey(bayKey: string): FakeCell | null {
+    const parts = bayKey.split('-').map(Number)
+    if (parts.length !== 2) return null
+    return this.cellAt(parts[0], parts[1])
+  }
+
+  parseCellId(cellId: string) {
+    const parts = cellId.split('-').map(Number)
+    if (parts.length !== 3 || parts.some(n => !Number.isFinite(n))) return null
+    return { col: parts[0], row: parts[1], shelf: parts[2] }
+  }
+
+  parsePosKey(posKey: string) {
+    const parts = posKey.split('-').map(Number)
+    if (parts.length !== 2 || parts.some(n => !Number.isFinite(n))) return null
+    return { col: parts[0], row: parts[1] }
+  }
+
+  private _shelfLabelsFromCell(cellShelfLocations: string | undefined): string[] {
+    const input = cellShelfLocations ?? this.state.shelfLocations
+    const levels = this.shelves
+    const parts = (input || '').split(',')
+    const out: string[] = []
+    for (let i = 0; i < levels; i++) {
+      const p = parts[i]
+      out[i] = p && p.trim().length > 0 ? p.trim() : String(i + 1)
+    }
+    return out
+  }
+
+  locationOf(cellId: string): string | null {
+    const parsed = this.parseCellId(cellId)
+    if (!parsed) return null
+    const posKey = `${parsed.col}-${parsed.row}`
+
+    let section, unit, isEmpty, cellShelfLocations: string | undefined
+    const cell = this.cellAt(parsed.col, parsed.row)
+    if (cell) {
+      section = cell.state.section
+      unit = cell.state.unit
+      isEmpty = cell.state.isEmpty
+      cellShelfLocations = cell.state.shelfLocations
+    } else {
+      const o = this.cellOverrides[posKey]
+      section = o?.section; unit = o?.unit; isEmpty = o?.isEmpty
+    }
+
+    if (!section || !unit || isEmpty) return null
+    const pattern = this.state.locPattern ?? '{z}{s}-{u}-{sh}'
+    const zone = this.state.zone ?? ''
+    const shelfLabel = this._shelfLabelsFromCell(cellShelfLocations)[parsed.shelf] ?? String(parsed.shelf + 1)
+    return pattern
+      .replace(/\{z\}/g, zone)
+      .replace(/\{s\}/g, section)
+      .replace(/\{u\}/g, unit)
+      .replace(/\{sh\}/g, shelfLabel)
+  }
+
+  cellIdOfLocation(location: string): string | null {
+    return this._locationIndex.get(location) ?? null
+  }
+
+  private get _locationIndex(): Map<string, string> {
+    if (this._locationIndexCache) return this._locationIndexCache
+    const map = new Map<string, string>()
+    const shelves = this.shelves
+
+    // cells first
+    for (const cell of this.components) {
+      if (cell.state.type !== 'rack-grid-cell') continue
+      const bayKey = cell.state.cellId
+      if (!bayKey) continue
+      const parsed = this.parsePosKey(bayKey)
+      if (!parsed) continue
+      for (let s = 0; s < shelves; s++) {
+        const cellId = `${parsed.col}-${parsed.row}-${s}`
+        const loc = this.locationOf(cellId)
+        if (loc) map.set(loc, cellId)
+      }
+    }
+    // overrides fallback
+    for (const posKey of Object.keys(this.cellOverrides)) {
+      const o = this.cellOverrides[posKey]
+      if (!o.section || !o.unit || o.isEmpty) continue
+      const parsed = this.parsePosKey(posKey)
+      if (!parsed) continue
+      for (let s = 0; s < shelves; s++) {
+        const cellId = `${parsed.col}-${parsed.row}-${s}`
+        const loc = this.locationOf(cellId)
+        if (loc && !map.has(loc)) map.set(loc, cellId)
+      }
+    }
+
+    this._locationIndexCache = map
+    return map
+  }
+
+  setIsEmpty(posKeys: string[], isEmpty: boolean): void {
+    const hasCells = this.components.some(c => c.state.type === 'rack-grid-cell')
+    if (hasCells) {
+      for (const k of posKeys) {
+        const cell = this.cellAtBayKey(k)
+        cell?.set('isEmpty', isEmpty)
+      }
+      this.invalidateLocationIndex()
+      return
+    }
+    // fallback
+    const current = this.cellOverrides
+    const next = { ...current }
+    for (const k of posKeys) {
+      const existing = next[k] ?? {}
+      const merged: any = { ...existing, isEmpty }
+      if (!isEmpty && !existing.section && !existing.unit) delete next[k]
+      else next[k] = merged
+    }
+    this.setState({ cellOverrides: next })
+  }
+}
+
+// ── 1: cell-component 가 있을 때 locationOf cell.state 직접 lookup ──────────
+
+describe('RackGridCell: cell.state 가 source of truth', () => {
+  it('cell.state.section/unit 명시 → location 부여', () => {
+    const g = new MiniGridWithCells()
+    g.cellAt(0, 0)!.set({ section: '01', unit: '01' })
+    g.locationOf('0-0-0').should.equal('Z01-01-1')
+    g.locationOf('0-0-3').should.equal('Z01-01-4')
+  })
+
+  it('section 만 / unit 만 → null', () => {
+    const g = new MiniGridWithCells()
+    g.cellAt(0, 0)!.set({ section: '01' })
+    ;(g.locationOf('0-0-0') === null).should.be.true()
+    g.cellAt(1, 0)!.set({ unit: '02' })
+    ;(g.locationOf('1-0-0') === null).should.be.true()
+  })
+
+  it('cell.state.isEmpty=true → location null', () => {
+    const g = new MiniGridWithCells()
+    g.cellAt(0, 0)!.set({ section: '01', unit: '01', isEmpty: true })
+    ;(g.locationOf('0-0-0') === null).should.be.true()
+  })
+
+  it('cell.state.shelfLocations 가 RackGrid.shelfLocations 보다 우선', () => {
+    const g = new MiniGridWithCells({ shelfLocations: 'A,B,C,D' })
+    g.cellAt(0, 0)!.set({ section: '01', unit: '01' })
+    g.locationOf('0-0-0').should.equal('Z01-01-A')
+    // cell-specific override
+    g.cellAt(0, 0)!.set('shelfLocations', 'X,Y,Z,W')
+    g.locationOf('0-0-0').should.equal('Z01-01-X')
+    g.locationOf('0-0-3').should.equal('Z01-01-W')
+  })
+
+  it('cell.state 변경 → location 역인덱스 무효화 (invalidate 후 재구축)', () => {
+    const g = new MiniGridWithCells()
+    g.cellAt(0, 0)!.set({ section: '01', unit: '01' })
+    g.cellIdOfLocation('Z01-01-1').should.equal('0-0-0')
+    // cell 의 section 변경
+    g.cellAt(0, 0)!.set('section', '02')
+    g.invalidateLocationIndex()  // cell.set 이 parent.invalidate 호출 시뮬
+    g.cellIdOfLocation('Z02-01-1').should.equal('0-0-0')
+    ;(g.cellIdOfLocation('Z01-01-1') === null).should.be.true()
+  })
+})
+
+// ── 2: setIsEmpty 가 cell-component 우선 mutate ─────────────────────────────
+
+describe('RackGridCell: setIsEmpty 는 cell.set() 우선', () => {
+  it('cell-component 있으면 cell.state.isEmpty 갱신 (cellOverrides 무영향)', () => {
+    const g = new MiniGridWithCells()
+    g.setIsEmpty(['1-0', '2-0'], true)
+    g.cellAt(1, 0)!.state.isEmpty!.should.be.true()
+    g.cellAt(2, 0)!.state.isEmpty!.should.be.true()
+    Object.keys(g.cellOverrides).length.should.equal(0)  // fallback 안 침범
+  })
+
+  it('cell-component 없으면 cellOverrides 갱신 (fallback)', () => {
+    const g = new MiniGridWithCells({}, { withCells: false })
+    g.setIsEmpty(['1-0'], true)
+    g.cellOverrides['1-0'].isEmpty!.should.be.true()
+  })
+})
+
+// ── 3: cellOverrides fallback 도 여전히 동작 (cell-component 없을 때) ──────
+
+describe('RackGridCell: cellOverrides fallback 호환', () => {
+  it('cell-component 없으면 cellOverrides 가 source of truth', () => {
+    const g = new MiniGridWithCells({
+      cellOverrides: { '0-0': { section: '01', unit: '01' } }
+    }, { withCells: false })
+    g.locationOf('0-0-0').should.equal('Z01-01-1')
+    g.cellIdOfLocation('Z01-01-1').should.equal('0-0-0')
+  })
+
+  it('cell-component 있으면 cellOverrides 무시 (cell.state 가 single source of truth)', () => {
+    // cell-component 가 있으면 *그 cell.state 만* lookup. cellOverrides 의 동일 bayKey
+    // 데이터는 무시됨 → cell-component 의 데이터로 일관. (transitional load 시 별도
+    // migrate 로직이 cellOverrides → cell.state 옮김)
+    const g = new MiniGridWithCells({
+      cellOverrides: { '3-0': { section: '02', unit: '03' } }
+    })
+    ;(g.locationOf('3-0-0') === null).should.be.true()  // cell.state 비어있음 → null
+  })
+})
+
+// ── 4: cell-component 의 cellId 동기화 (순서 기반 bayKey) ──────────────────
+
+describe('RackGridCell: cellId 가 components 순서 기반', () => {
+  it('4×1 grid 에서 cellId 가 0-0, 1-0, 2-0, 3-0', () => {
+    const g = new MiniGridWithCells({ columns: 4, rows: 1 })
+    g.components[0].state.cellId!.should.equal('0-0')
+    g.components[1].state.cellId!.should.equal('1-0')
+    g.components[2].state.cellId!.should.equal('2-0')
+    g.components[3].state.cellId!.should.equal('3-0')
+  })
+
+  it('3×2 grid 에서 row-major 순서', () => {
+    const g = new MiniGridWithCells({ columns: 3, rows: 2 })
+    // row 0: 0-0, 1-0, 2-0
+    g.components[0].state.cellId!.should.equal('0-0')
+    g.components[1].state.cellId!.should.equal('1-0')
+    g.components[2].state.cellId!.should.equal('2-0')
+    // row 1: 0-1, 1-1, 2-1
+    g.components[3].state.cellId!.should.equal('0-1')
+    g.components[4].state.cellId!.should.equal('1-1')
+    g.components[5].state.cellId!.should.equal('2-1')
+  })
+})