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

package/test/test-carrier-lifecycle.ts

@@ -0,0 +1,361 @@
+/*
+ * Carrier Three.js lifecycle — pickAndPlace 단계별 *carrier.object3d 의 Three.js parent*
+ * 추적. ghost / teleport 같은 시각적 회귀의 근본 원인은 *어느 단계에서 parent 가 누락
+ * 또는 잘못 잡혀 있는가* 에 있음.
+ *
+ * 검증 4단계:
+ *   1. 갓 생성 (`new Carrier()`)        — object3d.parent === null
+ *   2. obtainCarrier 직후                 — object3d.parent === slot anchor (cellId 위치)
+ *   3. mover.pick 시뮬 (reparent)         — object3d.parent === crane fork object3d
+ *   4. mover.place 의 receiveAt 시뮬       — object3d.parent === null (detach 완료)
+ *
+ * 4단계 누락 시 ghost 잔존. 1-3 단계 누락 시 carrier 가 잘못된 위치 (rack origin, world
+ * origin 등) 에 그려져 "랙 꼭대기 / 어딘가의 ghost" 증상.
+ *
+ * 실 things-scene Component 인스턴스화 비현실적 → minimal Component-like 로 contract
+ * 만 isolate.
+ */
+
+import 'should'
+import * as THREE from 'three'
+
+// ── Minimal carrier (Plan A 의 transient carrier 대체) ──────────────────────────
+
+class FakeCarrier {
+  state: any
+  parent: any = null
+  _realObject: { object3d: THREE.Object3D }
+  _disposed = false
+
+  constructor(state: any) {
+    this.state = state
+    this._realObject = { object3d: new THREE.Object3D() }
+    this._realObject.object3d.name = `carrier:${state.id ?? state.cellId ?? '?'}`
+  }
+
+  // Carriable.applyHolderAttachPoint 시뮬 — parent.attachPointFor 호출 후 Three.js attach
+  applyHolderAttachPoint(): void {
+    const p: any = this.parent
+    if (!p?.attachPointFor) return
+    const point = p.attachPointFor(this)
+    if (!point?.attach) return
+    point.attach.attach(this._realObject.object3d)
+    if (point.localPosition) {
+      this._realObject.object3d.position.set(
+        point.localPosition.x, point.localPosition.y, point.localPosition.z
+      )
+    }
+  }
+
+  dispose(): void {
+    this._disposed = true
+    // RealObject.dispose 가 children 만 정리, object3d 자체는 안 떼는 결함의 시뮬:
+    // children 만 제거.
+    this._realObject.object3d.clear()
+    // 만약 Plan A 의 receiveAt 명시 detach 가 정상이면 *전* 에 이미 parent.remove 됐어야 함.
+  }
+}
+
+// ── Minimal rack (SlottedHolder contract 대체) ──────────────────────────────────
+
+class FakeRack {
+  state: any = { data: [] }
+  components: any[] = []
+  rootObject3d = new THREE.Group()
+  _slotAnchors = new Map<string, THREE.Object3D>()
+
+  constructor() { this.rootObject3d.name = 'rack' }
+
+  addComponent(c: any): void {
+    c.parent = this
+    this.components.push(c)
+  }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+
+  attachPointFor(carrier: any): { attach: THREE.Object3D; localPosition: { x: number; y: number; z: number } } {
+    const cellId = carrier.state.cellId
+    let anchor = this._slotAnchors.get(cellId)
+    if (!anchor) {
+      anchor = new THREE.Object3D()
+      anchor.name = `slot:${cellId}`
+      const bay = Number(cellId.split('-')[0] ?? 0)
+      anchor.position.set(bay * 100, 50, 0)   // bay-별 X, level center Y
+      this.rootObject3d.add(anchor)
+      this._slotAnchors.set(cellId, anchor)
+    }
+    return { attach: anchor, localPosition: { x: 0, y: 0, z: 0 } }
+  }
+
+  obtainCarrier(cellId: string): FakeCarrier | null {
+    const records = this.state.data as any[]
+    const i = records.findIndex(r => r.cellId === cellId)
+    if (i === -1) return null
+    const record = records[i]
+    const carrier = new FakeCarrier({ ...record, cellId })
+    this.addComponent(carrier)
+    carrier.applyHolderAttachPoint()
+    this.state.data = records.filter((_, j) => j !== i)
+    return carrier
+  }
+
+  async receiveAt(cellId: string, carrier: any): Promise<void> {
+    // Plan A 의 receiveAt 흐름 그대로:
+    // 1. parent 에서 분리 (Component)
+    const p = carrier.parent
+    if (p?.removeComponent) p.removeComponent(carrier)
+
+    // 2. Three.js detach 명시 — 이게 RealObject.dispose 만으론 안 되는 부분
+    const obj = carrier._realObject?.object3d
+    if (obj?.parent?.remove) obj.parent.remove(obj)
+
+    // 3. dispose
+    carrier.dispose()
+
+    // 4. record push
+    const rec: any = { cellId, type: carrier.state.type ?? 'parcel' }
+    for (const k of Object.keys(carrier.state)) {
+      if (['id', 'left', 'top', 'zPos', 'cellId', '_transferSlotId'].includes(k)) continue
+      rec[k] = carrier.state[k]
+    }
+    this.state.data = [...this.state.data, rec]
+  }
+}
+
+// ── Minimal crane (Mover 시뮬) ──────────────────────────────────────────────────
+
+class FakeCrane {
+  components: any[] = []
+  forkObject3d = new THREE.Object3D()
+
+  constructor() { this.forkObject3d.name = 'crane-fork' }
+
+  addComponent(c: any): void { c.parent = this; this.components.push(c) }
+  removeComponent(c: any): void {
+    const i = this.components.indexOf(c)
+    if (i >= 0) this.components.splice(i, 1)
+    c.parent = null
+  }
+
+  attachPointFor(_carrier: any): { attach: THREE.Object3D; localPosition: { x: number; y: number; z: number } } {
+    return { attach: this.forkObject3d, localPosition: { x: 0, y: 0, z: 0 } }
+  }
+
+  // pick 의 reparent 단계 시뮬 — Component 측 reparent + Three.js attach
+  simulatePick(carrier: any): void {
+    const oldParent = carrier.parent
+    if (oldParent?.removeComponent) oldParent.removeComponent(carrier)
+    this.addComponent(carrier)
+    // Three.js attach
+    const obj = carrier._realObject.object3d
+    this.forkObject3d.attach(obj)
+    obj.position.set(0, 0, 0)
+  }
+}
+
+// ── Group 1: 갓 생성 단계 ────────────────────────────────────────────────────
+
+describe('Carrier lifecycle: 갓 생성', () => {
+  it('새 carrier 의 object3d.parent === null', () => {
+    const c = new FakeCarrier({ cellId: 'A' })
+    ;(c._realObject.object3d.parent === null).should.be.true()
+  })
+
+  it('Component-level parent 도 null', () => {
+    const c = new FakeCarrier({ cellId: 'A' })
+    ;(c.parent === null).should.be.true()
+  })
+})
+
+// ── Group 2: obtainCarrier 직후 ─────────────────────────────────────────────
+
+describe('Carrier lifecycle: obtainCarrier 직후', () => {
+  it('Component-level parent === rack', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A-0-1', type: 'parcel' }]
+    const c = rack.obtainCarrier('A-0-1')!
+    c.parent.should.equal(rack)
+  })
+
+  it('object3d.parent === slot anchor (rack 의 자식)', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A-0-1' }]
+    const c = rack.obtainCarrier('A-0-1')!
+    const objParent = c._realObject.object3d.parent
+    objParent!.name.should.equal('slot:A-0-1')
+    objParent!.parent!.should.equal(rack.rootObject3d)
+  })
+
+  it('object3d.position === (0,0,0) — slot anchor origin 으로 snap', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A-0-1' }]
+    const c = rack.obtainCarrier('A-0-1')!
+    const p = c._realObject.object3d.position
+    p.x.should.equal(0)
+    p.y.should.equal(0)
+    p.z.should.equal(0)
+  })
+
+  it('state.data 에서 그 record 제거됨', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A', sku: 'X' }, { cellId: 'B', sku: 'Y' }]
+    rack.obtainCarrier('A')
+    rack.state.data.length.should.equal(1)
+    rack.state.data[0].cellId.should.equal('B')
+  })
+})
+
+// ── Group 3: simulated pick (rack → crane) ──────────────────────────────────
+
+describe('Carrier lifecycle: pick (rack → crane) 후', () => {
+  it('Component-level parent === crane', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+
+    crane.simulatePick(c)
+    c.parent.should.equal(crane)
+  })
+
+  it('object3d.parent === crane.forkObject3d', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+
+    crane.simulatePick(c)
+    c._realObject.object3d.parent!.name.should.equal('crane-fork')
+  })
+
+  it('rack.components 에서 carrier 사라짐', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+
+    crane.simulatePick(c)
+    rack.components.length.should.equal(0)
+    crane.components.length.should.equal(1)
+    crane.components[0].should.equal(c)
+  })
+
+  it('slot anchor object3d 는 rack 에 그대로 남음 (재사용 가능)', () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+
+    crane.simulatePick(c)
+    const anchor = rack._slotAnchors.get('A')
+    anchor!.parent!.should.equal(rack.rootObject3d)
+    anchor!.children.length.should.equal(0)   // carrier 가 떠났으므로 비어있음
+  })
+})
+
+// ── Group 4: receiveAt — carrier 가 다시 rack 으로 (BUT 데이터로 환원) ────────
+
+describe('Carrier lifecycle: receiveAt (crane → rack) 후', () => {
+  it('Component-level parent === null (어디에도 안 속함)', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    await rack.receiveAt('B', c)
+    ;(c.parent === null).should.be.true()
+  })
+
+  it('object3d.parent === null — Three.js scene graph 에서 detach 완료', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    await rack.receiveAt('B', c)
+    ;(c._realObject.object3d.parent === null).should.be.true()
+  })
+
+  it('crane.forkObject3d 의 자식에 carrier 없음 (ghost X)', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    await rack.receiveAt('B', c)
+    crane.forkObject3d.children.length.should.equal(0)
+    crane.components.length.should.equal(0)
+  })
+
+  it('carrier 가 disposed 마킹됨', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    await rack.receiveAt('B', c)
+    c._disposed.should.be.true()
+  })
+
+  it('state.data 에 record 추가됨 — dest slot 으로', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A', sku: 'X', qty: 5 }]
+    const crane = new FakeCrane()
+    const c = rack.obtainCarrier('A')!
+    crane.simulatePick(c)
+
+    await rack.receiveAt('B', c)
+    rack.state.data.length.should.equal(1)
+    rack.state.data[0].cellId.should.equal('B')
+    rack.state.data[0].sku.should.equal('X')
+    rack.state.data[0].qty.should.equal(5)
+  })
+})
+
+// ── Group 5: 전체 round-trip 의 *불변식* — 매 단계 carrier 가 정확히 한 곳에만 있음 ──
+
+describe('Carrier lifecycle: 불변식 — 매 단계에서 carrier 가 정확히 한 holder 에만', () => {
+  it('obtain → pick → place 전체 흐름 — carrier 가 두 곳에 동시 존재 X', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A' }]
+    const crane = new FakeCrane()
+
+    // 1. obtain — carrier 는 rack 자식
+    const c = rack.obtainCarrier('A')!
+    rack.components.includes(c).should.be.true()
+    crane.components.includes(c).should.be.false()
+
+    // 2. pick — carrier 가 crane 자식, rack 에서 사라짐
+    crane.simulatePick(c)
+    rack.components.includes(c).should.be.false()
+    crane.components.includes(c).should.be.true()
+
+    // 3. receiveAt('B') — carrier 가 어디에도 없음 (data 로 환원)
+    await rack.receiveAt('B', c)
+    rack.components.includes(c).should.be.false()
+    crane.components.includes(c).should.be.false()
+    ;(c.parent === null).should.be.true()
+  })
+
+  it('state.data 의 record count 보존 — 1개 시작 → 1개 끝 (cellId 만 다름)', async () => {
+    const rack = new FakeRack()
+    rack.state.data = [{ cellId: 'A', sku: 'X' }]
+    const crane = new FakeCrane()
+
+    const c = rack.obtainCarrier('A')!
+    rack.state.data.length.should.equal(0)       // obtain 후 record 빠짐
+    crane.simulatePick(c)
+    rack.state.data.length.should.equal(0)       // pick 으로 변동 없음
+    await rack.receiveAt('B', c)
+    rack.state.data.length.should.equal(1)       // place 후 record 추가
+    rack.state.data[0].cellId.should.equal('B')  // 새 cellId 로
+    rack.state.data[0].sku.should.equal('X')     // 데이터 보존
+  })
+})

package/test/test-coord-alignment.ts

@@ -0,0 +1,201 @@
+/*
+ * 좌표 정렬 검증 — anchor (Crane fork 가 target 하는 점) 가 InstancedMesh stock 의
+ * 시각 위치와 *수학적으로* 일치하는지.
+ *
+ * 두 공식이 *동일 cellId 에 대해 동일 결과* 를 반환해야 함:
+ *   - storage-rack-3d.rebuildStockMesh: InstancedMesh instance 의 위치
+ *   - storage-rack._ensureCellAttachObject3d: anchor (SlotTarget._realObject.object3d) 위치
+ *
+ * 불일치 = Crane fork 가 stock 시각 위치와 어긋남.
+ *
+ * 추가:
+ *   - SlotTarget.state.depth 가 stockD 와 일치 (Crane.resolveCarrierBottomY 가 shelf 정확히)
+ *   - cellCenter2D 가 rack-local 좌표 반환 (rack.left/top 미포함)
+ */
+
+import 'should'
+
+// ── 공식 재현 (storage-rack.ts / storage-rack-3d.ts 에서 정확히 그대로) ────────
+
+function computeStockPosition(
+  cell: { localPosition: { x: number; y: number; z: number } },
+  rackParams: { width: number; depth: number; height: number; bays: number; levels: number; shelfBase: number }
+) {
+  const { width, depth, height, bays, levels, shelfBase } = rackParams
+  const shelfZone = depth - shelfBase
+  const bayWidth = width / bays
+  const levelHeight = shelfZone / levels
+  const stockD = levelHeight * 0.7
+  const rowDepth = height
+
+  // storage-rack-3d.ts rebuildStockMesh 공식
+  const x = cell.localPosition.x + bayWidth / 2 - width / 2
+  const cellCenterY = cell.localPosition.y + levelHeight / 2 - depth / 2
+  const y = cellCenterY - levelHeight / 2 + stockD / 2
+  const z = cell.localPosition.z + rowDepth / 2 - height / 2
+  return { x, y, z }
+}
+
+function computeAnchorPosition(
+  cell: { localPosition: { x: number; y: number; z: number } },
+  rackParams: { width: number; depth: number; height: number; bays: number; levels: number; shelfBase: number }
+) {
+  const { width, depth, height, bays, levels, shelfBase } = rackParams
+  const shelfZone = depth - shelfBase
+  const bayWidth = width / bays
+  const levelHeight = shelfZone / levels
+  const stockD = levelHeight * 0.7
+  const rowDepth = height
+
+  // storage-rack.ts _ensureCellAttachObject3d 공식
+  const x = cell.localPosition.x + bayWidth / 2 - width / 2
+  const y = cell.localPosition.y - depth / 2 + stockD / 2
+  const z = cell.localPosition.z + rowDepth / 2 - height / 2
+  return { x, y, z }
+}
+
+// CellMap.grid 시뮬 — 셀의 localPosition 생성 (rack 의 bottom-left-front 원점)
+function makeCell(bay: number, row: number, level: number, p: { bayWidth: number; rowDepth: number; levelHeight: number; shelfBase: number }) {
+  return {
+    bay,
+    row,
+    level,
+    localPosition: {
+      x: (bay - 1) * p.bayWidth,
+      y: p.shelfBase + (level - 1) * p.levelHeight,
+      z: (row - 1) * p.rowDepth
+    }
+  }
+}
+
+// ── Group 1: anchor 와 stock 위치 일치 ──────────────────────────────────────
+
+describe('Coord: anchor (Crane target) 가 stock visual 위치와 일치', () => {
+  const rackParams = { width: 1000, depth: 3000, height: 600, bays: 5, levels: 4, shelfBase: 0 }
+  const bayWidth = rackParams.width / rackParams.bays
+  const levelHeight = (rackParams.depth - rackParams.shelfBase) / rackParams.levels
+  const rowDepth = rackParams.height
+
+  function makeCellHere(b: number, r: number, l: number) {
+    return makeCell(b, r, l, { bayWidth, rowDepth, levelHeight, shelfBase: rackParams.shelfBase })
+  }
+
+  it('bay=1, row=1, level=1 — anchor === stock', () => {
+    const c = makeCellHere(1, 1, 1)
+    const s = computeStockPosition(c, rackParams)
+    const a = computeAnchorPosition(c, rackParams)
+    a.should.deepEqual(s)
+  })
+
+  it('bay=3, row=1, level=4 (마지막 level) — anchor === stock', () => {
+    const c = makeCellHere(3, 1, 4)
+    const s = computeStockPosition(c, rackParams)
+    const a = computeAnchorPosition(c, rackParams)
+    a.should.deepEqual(s)
+  })
+
+  it('bay=5, row=1, level=4 (rack 의 마지막 셀) — anchor === stock', () => {
+    const c = makeCellHere(5, 1, 4)
+    const s = computeStockPosition(c, rackParams)
+    const a = computeAnchorPosition(c, rackParams)
+    a.should.deepEqual(s)
+  })
+
+  it('shelfBase > 0 — anchor === stock (10개 cell sampling)', () => {
+    const rp = { ...rackParams, shelfBase: 200 }
+    const lh = (rp.depth - rp.shelfBase) / rp.levels
+    for (let b = 1; b <= rp.bays; b++) {
+      for (let l = 1; l <= rp.levels; l++) {
+        const c = makeCell(b, 1, l, { bayWidth, rowDepth, levelHeight: lh, shelfBase: rp.shelfBase })
+        const s = computeStockPosition(c, rp)
+        const a = computeAnchorPosition(c, rp)
+        a.should.deepEqual(s)
+      }
+    }
+  })
+})
+
+// ── Group 2: Crane fork bottom = shelf (resolveCarrierBottomY 공식) ────────
+
+describe('Coord: Crane fork bottom = shelf level', () => {
+  // resolveCarrierBottomY = centerY - depth/2
+  // 여기서 centerY = anchor.y, depth = SlotTarget.state.depth = stockD
+  it('anchor.y - stockD/2 = cellBottom (= shelf level)', () => {
+    const p = { width: 1000, depth: 3000, height: 600, bays: 5, levels: 4, shelfBase: 0 }
+    const lh = (p.depth - p.shelfBase) / p.levels
+    const stockD = lh * 0.7
+    const cell = makeCell(2, 1, 2, { bayWidth: p.width / p.bays, rowDepth: p.height, levelHeight: lh, shelfBase: p.shelfBase })
+    const anchor = computeAnchorPosition(cell, p)
+
+    const carrierBottom = anchor.y - stockD / 2
+    const cellBottom = cell.localPosition.y - p.depth / 2   // rack-local 의 cell 바닥 = shelf
+    carrierBottom.should.be.approximately(cellBottom, 0.001)
+  })
+
+  it('잘못된 case — depth = levelHeight 면 fork 가 shelf 보다 아래', () => {
+    // 이전 결함: SlotTarget.state.depth = levelHeight (전체 셀) 였을 때
+    const p = { width: 1000, depth: 3000, height: 600, bays: 5, levels: 4, shelfBase: 0 }
+    const lh = (p.depth - p.shelfBase) / p.levels
+    const stockD = lh * 0.7
+    const cell = makeCell(2, 1, 2, { bayWidth: p.width / p.bays, rowDepth: p.height, levelHeight: lh, shelfBase: p.shelfBase })
+    const anchor = computeAnchorPosition(cell, p)
+    const cellBottom = cell.localPosition.y - p.depth / 2
+
+    // BAD: depth = levelHeight
+    const badBottom = anchor.y - lh / 2
+    badBottom.should.not.be.approximately(cellBottom, 0.001)
+    // 차이 = (levelHeight - stockD)/2 = 0.15·levelHeight
+    Math.abs(badBottom - cellBottom).should.be.approximately((lh - stockD) / 2, 0.001)
+  })
+})
+
+// ── Group 3: cellCenter2D — rack-local 좌표 반환 ─────────────────────────────
+
+describe('Coord: cellCenter2D 가 rack-local 좌표 반환 (rack.left/top 미포함)', () => {
+  function computeCellCenter2D(
+    cellId: string,
+    rs: { width: number; height: number; bays: number; left?: number; top?: number }
+  ) {
+    const bayIdx = Number(cellId.split('-')[0] ?? 0)
+    const bayWidth = rs.width / rs.bays
+    // 새 공식 (Plan A fix): rack-local — left/top 미포함
+    return {
+      x: bayIdx * bayWidth + bayWidth / 2,
+      y: rs.height / 2
+    }
+  }
+
+  it('rack.left = 100 이어도 cellCenter2D 는 *rack-local* 좌표', () => {
+    const rs = { width: 1000, height: 100, bays: 5, left: 100, top: 50 }
+    const c = computeCellCenter2D('2-0-0', rs)
+    // bay 2, bayWidth=200, center = 2*200 + 100 = 500 (rack-local, 0-based)
+    c.x.should.equal(500)
+    c.y.should.equal(50)   // rack-local Y center = rack.height/2 = 50
+    // rack.left/top 가 포함되지 *않아야* 함 (이전 결함은 포함했음)
+    ;(c.x === rs.left).should.be.false()
+  })
+
+  it('bay 인덱스별 X 위치', () => {
+    const rs = { width: 1000, height: 100, bays: 5 }
+    const bw = rs.width / rs.bays
+    for (let b = 0; b < 5; b++) {
+      const c = computeCellCenter2D(`${b}-0-0`, rs)
+      c.x.should.equal(b * bw + bw / 2)
+    }
+  })
+})
+
+// ── Group 4: SlotTarget.state.depth = stockD ────────────────────────────────
+
+describe('Coord: SlotTarget.state.depth = stockD (carrier 의 실제 depth)', () => {
+  it('cell.size.height * 0.7 = stockD = state.depth', () => {
+    // CellMap.grid 에서 size.height = levelHeight
+    const levelHeight = 600
+    const cellSizeHeight = levelHeight
+    const stockD = cellSizeHeight * 0.7
+    // Plan A 의 getSlotSize 가 반환하는 depth
+    stockD.should.equal(420)
+    // *전체 levelHeight 가 아님*
+    stockD.should.not.equal(levelHeight)
+  })
+})