tests: observer tests should use deep equal

packages/utils/src/observe.ts

@@ -58,6 +58,7 @@ function observeObject<T extends object>(target: T, label: string, update?: () =
         update()
       } else {
         delete diff[key]
+        delete getters[key]
       }
       return Reflect.deleteProperty(target, key)
     },

packages/utils/tests/observe.spec.ts

@@ -26,52 +26,93 @@ describe('Observer API', () => {
   it('observe property', () => {
     const target: Dict<number> = { a: 1, b: 2 }
     const object = observe(target, 'foo')
-    expect(object.$diff).to.have.shape({})
+    expect(object.$diff).to.deep.equal({})
 
     object.a = 1
-    expect(object).to.have.shape({ a: 1, b: 2 })
-    expect(object.$diff).to.have.shape({})
+    expect(object).to.deep.equal({ a: 1, b: 2 })
+    expect(object.$diff).to.deep.equal({})
 
     object.a = 2
-    expect(object).to.have.shape({ a: 2, b: 2 })
-    expect(object.$diff).to.have.shape({ a: 2 })
+    expect(object).to.deep.equal({ a: 2, b: 2 })
+    expect(object.$diff).to.deep.equal({ a: 2 })
 
     object.c = 3
-    expect(object).to.have.shape({ a: 2, b: 2, c: 3 })
-    expect(object.$diff).to.have.shape({ a: 2, c: 3 })
+    expect(object).to.deep.equal({ a: 2, b: 2, c: 3 })
+    expect(object.$diff).to.deep.equal({ a: 2, c: 3 })
 
     delete object.b
-    expect(object).to.have.shape({ a: 2, c: 3 })
-    expect(object.$diff).to.have.shape({ a: 2, c: 3 })
+    expect(object).to.deep.equal({ a: 2, c: 3 })
+    expect(object.$diff).to.deep.equal({ a: 2, c: 3 })
 
     delete object.c
-    expect(object).to.have.shape({ a: 2 })
-    expect(object.$diff).to.have.shape({ a: 2 })
+    expect(object).to.deep.equal({ a: 2 })
+    expect(object.$diff).to.deep.equal({ a: 2 })
   })
 
   it('deep observe', () => {
-    const object = observe<any>({ a: { b: 1 }, c: [{ d: 2 }], x: [{ y: 3 }] }, 'foo')
-    expect(object.$diff).to.have.shape({})
+    const object = observe<any>({
+      a: { b: 1 },
+      c: [{ d: 2 }],
+      x: [{ y: 3 }],
+    }, 'foo')
+    expect(object.$diff).to.deep.equal({})
 
     object.a.e = 3
-    expect(object).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }], x: [{ y: 3 }] })
-    expect(object.$diff).to.have.shape({ a: { b: 1, e: 3 } })
+    expect(object).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }],
+      x: [{ y: 3 }],
+    })
+    expect(object.$diff).to.deep.equal({
+      a: { b: 1, e: 3 },
+    })
 
     object.c.push({ f: 4 })
-    expect(object).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 3 }] })
-    expect(object.$diff).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }, { f: 4 }] })
+    expect(object).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 3 }],
+    })
+    expect(object.$diff).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+    })
 
     object.x[0].y = 4
-    expect(object).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 4 }] })
-    expect(object.$diff).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 4 }] })
+    expect(object).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 4 }],
+    })
+    expect(object.$diff).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 4 }],
+    })
 
     object.x[1] = [5]
-    expect(object).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 4 }, [5]] })
-    expect(object.$diff).to.have.shape({ a: { b: 1, e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 4 }, [5]] })
+    expect(object).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 4 }, [5]],
+    })
+    expect(object.$diff).to.deep.equal({
+      a: { b: 1, e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 4 }, [5]],
+    })
 
     delete object.a.b
-    expect(object).to.have.shape({ a: { e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 4 }, [5]] })
-    expect(object.$diff).to.have.shape({ a: { e: 3 }, c: [{ d: 2 }, { f: 4 }], x: [{ y: 4 }, [5]] })
+    expect(object).to.deep.equal({
+      a: { e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 4 }, [5]],
+    })
+    expect(object.$diff).to.deep.equal({
+      a: { e: 3 },
+      c: [{ d: 2 }, { f: 4 }],
+      x: [{ y: 4 }, [5]],
+    })
   })
 
   it('observe date', () => {
@@ -85,46 +126,46 @@ describe('Observer API', () => {
   it('flush changes', () => {
     const flush = jest.fn()
     const object = observe({ a: 1, b: [2] }, flush)
-    expect(object.$diff).to.have.shape({})
+    expect(object.$diff).to.deep.equal({})
 
     object.$update()
     expect(flush.mock.calls).to.have.length(0)
 
     object.b.shift()
-    expect(object).to.have.shape({ a: 1, b: [] })
-    expect(object.$diff).to.have.shape({ b: [] })
+    expect(object).to.deep.equal({ a: 1, b: [] })
+    expect(object.$diff).to.deep.equal({ b: [] })
 
     object.$update()
     expect(flush.mock.calls).to.have.length(1)
-    expect(flush.mock.calls[0]).to.have.shape([{ b: [] }])
-    expect(object).to.have.shape({ a: 1, b: [] })
-    expect(object.$diff).to.have.shape({})
+    expect(flush.mock.calls[0]).to.deep.equal([{ b: [] }])
+    expect(object).to.deep.equal({ a: 1, b: [] })
+    expect(object.$diff).to.deep.equal({})
 
     object.a = 3
-    expect(object).to.have.shape({ a: 3, b: [] })
-    expect(object.$diff).to.have.shape({ a: 3 })
+    expect(object).to.deep.equal({ a: 3, b: [] })
+    expect(object.$diff).to.deep.equal({ a: 3 })
 
     object.$update()
     expect(flush.mock.calls).to.have.length(2)
-    expect(flush.mock.calls[1]).to.have.shape([{ a: 3 }])
-    expect(object).to.have.shape({ a: 3, b: [] })
-    expect(object.$diff).to.have.shape({})
+    expect(flush.mock.calls[1]).to.deep.equal([{ a: 3 }])
+    expect(object).to.deep.equal({ a: 3, b: [] })
+    expect(object.$diff).to.deep.equal({})
   })
 
   it('merge properties', () => {
     const object = observe<any>({ a: 1 })
-    expect(object.$diff).to.have.shape({})
+    expect(object.$diff).to.deep.equal({})
 
     object.a = 2
-    expect(object).to.have.shape({ a: 2 })
-    expect(object.$diff).to.have.shape({ a: 2 })
+    expect(object).to.deep.equal({ a: 2 })
+    expect(object.$diff).to.deep.equal({ a: 2 })
 
     object.$merge({ b: 3 })
-    expect(object).to.have.shape({ a: 2, b: 3 })
-    expect(object.$diff).to.have.shape({ a: 2 })
+    expect(object).to.deep.equal({ a: 2, b: 3 })
+    expect(object.$diff).to.deep.equal({ a: 2 })
 
     expect(() => object.$merge({ a: 3 })).to.throw()
-    expect(object).to.have.shape({ a: 2, b: 3 })
-    expect(object.$diff).to.have.shape({ a: 2 })
+    expect(object).to.deep.equal({ a: 2, b: 3 })
+    expect(object.$diff).to.deep.equal({ a: 2 })
   })
 })