vue3-yuanma/packages/observer/__tests__/immutable.spec.ts

340 lines
9.9 KiB
TypeScript
Raw Normal View History

import {
observable,
immutable,
unwrap,
isObservable,
isImmutable,
markNonReactive,
markImmutable,
lock,
unlock,
autorun
} from '../src'
describe('observer/immutable', () => {
let warn: any
beforeEach(() => {
warn = jest.spyOn(console, 'warn')
warn.mockImplementation(() => {})
})
afterEach(() => {
warn.mockRestore()
})
describe('Object', () => {
it('should make nested values immutable', () => {
const original = { foo: 1, bar: { baz: 2 } }
const observed = immutable(original)
expect(observed).not.toBe(original)
expect(isObservable(observed)).toBe(true)
expect(isImmutable(observed)).toBe(true)
expect(isObservable(original)).toBe(false)
expect(isImmutable(original)).toBe(false)
expect(isObservable(observed.bar)).toBe(true)
expect(isImmutable(observed.bar)).toBe(true)
expect(isObservable(original.bar)).toBe(false)
expect(isImmutable(original.bar)).toBe(false)
// get
expect(observed.foo).toBe(1)
// has
expect('foo' in observed).toBe(true)
// ownKeys
expect(Object.keys(observed)).toEqual(['foo', 'bar'])
})
it('should not allow mutation', () => {
const observed = immutable({ foo: 1, bar: { baz: 2 } })
observed.foo = 2
expect(observed.foo).toBe(1)
expect(warn).toHaveBeenCalledTimes(1)
observed.bar.baz = 3
expect(observed.bar.baz).toBe(2)
expect(warn).toHaveBeenCalledTimes(2)
})
it('should allow mutation when unlocked', () => {
const observed = immutable({ foo: 1, bar: { baz: 2 } })
unlock()
observed.foo = 2
observed.bar.baz = 3
lock()
expect(observed.foo).toBe(2)
expect(observed.bar.baz).toBe(3)
expect(warn).not.toHaveBeenCalled()
})
it('should not trigger autoruns when locked', () => {
const observed = immutable({ a: 1 })
let dummy
autorun(() => {
dummy = observed.a
})
expect(dummy).toBe(1)
observed.a = 2
expect(observed.a).toBe(1)
expect(dummy).toBe(1)
})
it('should trigger autoruns when unlocked', () => {
const observed = immutable({ a: 1 })
let dummy
autorun(() => {
dummy = observed.a
})
expect(dummy).toBe(1)
unlock()
observed.a = 2
lock()
expect(observed.a).toBe(2)
expect(dummy).toBe(2)
})
})
describe('Array', () => {
it('should make nested values immutable', () => {
const original: any[] = [{ foo: 1 }]
const observed = immutable(original)
expect(observed).not.toBe(original)
expect(isObservable(observed)).toBe(true)
expect(isImmutable(observed)).toBe(true)
expect(isObservable(original)).toBe(false)
expect(isImmutable(original)).toBe(false)
expect(isObservable(observed[0])).toBe(true)
expect(isImmutable(observed[0])).toBe(true)
expect(isObservable(original[0])).toBe(false)
expect(isImmutable(original[0])).toBe(false)
// get
expect(observed[0].foo).toBe(1)
// has
expect(0 in observed).toBe(true)
// ownKeys
expect(Object.keys(observed)).toEqual(['0'])
})
it('should not allow mutation', () => {
const observed: any = immutable([{ foo: 1 }])
observed[0] = 1
expect(observed[0]).not.toBe(1)
expect(warn).toHaveBeenCalledTimes(1)
observed[0].foo = 2
expect(observed[0].foo).toBe(1)
expect(warn).toHaveBeenCalledTimes(2)
// should block length mutation
observed.length = 0
expect(observed.length).toBe(1)
expect(observed[0].foo).toBe(1)
expect(warn).toHaveBeenCalledTimes(3)
// mutation methods invoke set/length internally and thus are blocked as well
observed.push(2)
expect(observed.length).toBe(1)
// push triggers two warnings on [1] and .length
expect(warn).toHaveBeenCalledTimes(5)
})
it('should allow mutation when unlocked', () => {
const observed: any[] = immutable([{ foo: 1, bar: { baz: 2 } }])
unlock()
observed[1] = 2
observed.push(3)
observed[0].foo = 2
observed[0].bar.baz = 3
lock()
expect(observed.length).toBe(3)
expect(observed[1]).toBe(2)
expect(observed[2]).toBe(3)
expect(observed[0].foo).toBe(2)
expect(observed[0].bar.baz).toBe(3)
expect(warn).not.toHaveBeenCalled()
})
it('should not trigger autoruns when locked', () => {
const observed = immutable([{ a: 1 }])
let dummy
autorun(() => {
dummy = observed[0].a
})
expect(dummy).toBe(1)
observed[0].a = 2
expect(observed[0].a).toBe(1)
expect(dummy).toBe(1)
observed[0] = { a: 2 }
expect(observed[0].a).toBe(1)
expect(dummy).toBe(1)
})
it('should trigger autoruns when unlocked', () => {
const observed = immutable([{ a: 1 }])
let dummy
autorun(() => {
dummy = observed[0].a
})
expect(dummy).toBe(1)
unlock()
observed[0].a = 2
expect(observed[0].a).toBe(2)
expect(dummy).toBe(2)
observed[0] = { a: 3 }
expect(observed[0].a).toBe(3)
expect(dummy).toBe(3)
observed.unshift({ a: 4 })
expect(observed[0].a).toBe(4)
expect(dummy).toBe(4)
lock()
})
})
;[Map, WeakMap].forEach((Collection: any) => {
describe(Collection.name, () => {
test('should make nested values immutable', () => {
const key1 = {}
const key2 = {}
const original = new Collection([[key1, {}], [key2, {}]])
const observed = immutable(original)
expect(observed).not.toBe(original)
expect(isObservable(observed)).toBe(true)
expect(isImmutable(observed)).toBe(true)
expect(isObservable(original)).toBe(false)
expect(isImmutable(original)).toBe(false)
expect(isObservable(observed.get(key1))).toBe(true)
expect(isImmutable(observed.get(key1))).toBe(true)
expect(isObservable(original.get(key1))).toBe(false)
expect(isImmutable(original.get(key1))).toBe(false)
})
test('should not allow mutation & not trigger autorun', () => {
const map = immutable(new Collection())
const key = {}
let dummy
autorun(() => {
dummy = map.get(key)
})
expect(dummy).toBeUndefined()
map.set(key, 1)
expect(dummy).toBeUndefined()
expect(map.has(key)).toBe(false)
expect(warn).toHaveBeenCalledTimes(1)
})
test('should allow mutation & trigger autorun when unlocked', () => {
const map = immutable(new Collection())
const key = {}
let dummy
autorun(() => {
dummy = map.get(key)
})
expect(dummy).toBeUndefined()
unlock()
map.set(key, 1)
lock()
expect(dummy).toBe(1)
expect(map.get(key)).toBe(1)
expect(warn).not.toHaveBeenCalled()
})
})
})
;[Set, WeakSet].forEach((Collection: any) => {
describe(Collection.name, () => {
test('should make nested values immutable', () => {
const key1 = {}
const key2 = {}
const original = new Collection([key1, key2])
const observed = immutable(original)
expect(observed).not.toBe(original)
expect(isObservable(observed)).toBe(true)
expect(isImmutable(observed)).toBe(true)
expect(isObservable(original)).toBe(false)
expect(isImmutable(original)).toBe(false)
expect(observed.has(observable(key1))).toBe(true)
expect(original.has(observable(key1))).toBe(false)
})
test('should not allow mutation & not trigger autorun', () => {
const set = immutable(new Collection())
const key = {}
let dummy
autorun(() => {
dummy = set.has(key)
})
expect(dummy).toBe(false)
set.add(key)
expect(dummy).toBe(false)
expect(set.has(key)).toBe(false)
expect(warn).toHaveBeenCalledTimes(1)
})
test('should allow mutation & trigger autorun when unlocked', () => {
const set = immutable(new Collection())
const key = {}
let dummy
autorun(() => {
dummy = set.has(key)
})
expect(dummy).toBe(false)
unlock()
set.add(key)
lock()
expect(dummy).toBe(true)
expect(set.has(key)).toBe(true)
expect(warn).not.toHaveBeenCalled()
})
})
})
test('calling observable on an immutable should return immutable', () => {
const a = immutable()
const b = observable(a)
expect(isImmutable(b)).toBe(true)
// should point to same original
expect(unwrap(a)).toBe(unwrap(b))
})
test('calling immutable on an observable should return immutable', () => {
const a = observable()
const b = immutable(a)
expect(isImmutable(b)).toBe(true)
// should point to same original
expect(unwrap(a)).toBe(unwrap(b))
})
test('observing already observed value should return same Proxy', () => {
const original = { foo: 1 }
const observed = immutable(original)
const observed2 = immutable(observed)
expect(observed2).toBe(observed)
})
test('observing the same value multiple times should return same Proxy', () => {
const original = { foo: 1 }
const observed = immutable(original)
const observed2 = immutable(original)
expect(observed2).toBe(observed)
})
test('markNonReactive', () => {
const obj = immutable({
foo: { a: 1 },
bar: markNonReactive({ b: 2 })
})
expect(isObservable(obj.foo)).toBe(true)
expect(isObservable(obj.bar)).toBe(false)
})
test('markImmutable', () => {
const obj = observable({
foo: { a: 1 },
bar: markImmutable({ b: 2 })
})
expect(isObservable(obj.foo)).toBe(true)
expect(isObservable(obj.bar)).toBe(true)
expect(isImmutable(obj.foo)).toBe(false)
expect(isImmutable(obj.bar)).toBe(true)
})
})