test: improve test coverage (#2413)

* test(useIDBKeyval): ut coverage statements 96.87% branches 95% functions 100% lines 96.87%

* test(useIDBKeyval): make sure error callback invoked

* test(useIDBKeyval): mock idb-keyval

* test(useIntervalFn):useIntervalFn ut statements 100% branches 100% functions 100% lines 100%

* test(until):until ut statements 100% branches 100% functions 100% lines 100%

packages/shared/until/index.test.ts

@@ -5,13 +5,76 @@ import type { Equal, Expect } from '@type-challenges/utils'
 import { until } from '.'
 
 describe('until', () => {
-  it('should work', () => {
+  it('should toBe', () => {
     return new Promise<void>((resolve, reject) => {
+      const r1 = ref(0)
+      const r2 = ref(0)
+
+      invoke(async () => {
+        expect(r1.value).toBe(0)
+        expect(r2.value).toBe(0)
+        let x = await until(r1).toBe(1)
+        expect(x).toBe(1)
+        x = await until(r2).toBe(ref(2))
+        expect(x).toBe(2)
+        resolve()
+      }).catch(reject)
+
+      setTimeout(() => {
+        r1.value = 1
+        r2.value = 1
+      }, 100)
+
+      setTimeout(() => {
+        r2.value = 2
+      }, 200)
+    })
+  })
+
+  it('should toBeTruthy', async () => {
+    const r = ref(false)
+    setTimeout(() => {
+      r.value = true
+    }, 100)
+
+    expect(await until(r).toBeTruthy()).toBeTruthy()
+  })
+
+  it('should toBeUndefined', async () => {
+    const r = ref<boolean | undefined>(false)
+    setTimeout(() => {
+      r.value = undefined
+    }, 100)
+
+    expect(await until(r).toBeUndefined()).toBeUndefined()
+  })
+
+  it('should toBeNaN', async () => {
+    const r = ref(0)
+    setTimeout(() => {
+      r.value = NaN
+    }, 100)
+
+    expect(await until(r).toBeNaN()).toBeNaN()
+  })
+
+  it('should toBe timeout with ref', async () => {
+    const r = ref(0)
+    const reject = vi.fn()
+    await invoke(async () => {
+      await until(r).toBe(ref(1), { timeout: 200, throwOnTimeout: true })
+    }).catch(reject)
+
+    expect(reject).toHaveBeenCalledWith('Timeout')
+  })
+
+  it('should work for changedTimes', async () => {
+    await new Promise<void>((resolve, reject) => {
       const r = ref(0)
 
       invoke(async () => {
         expect(r.value).toBe(0)
-        const x = await until(r).toBe(1)
+        const x = await until(r).changed()
         expect(x).toBe(1)
         resolve()
       }).catch(reject)
@@ -20,10 +83,7 @@ describe('until', () => {
         r.value = 1
       }, 100)
     })
-  })
-
-  it('should work for changedTimes', () => {
-    return new Promise<void>((resolve, reject) => {
+    await new Promise<void>((resolve, reject) => {
       const r = ref(0)
 
       invoke(async () => {

packages/shared/useIntervalFn/index.test.ts

@@ -0,0 +1,100 @@
+import { effectScope, nextTick, ref } from 'vue-demi'
+import { promiseTimeout } from '@vueuse/shared'
+import type { Pausable } from '../utils'
+import { useIntervalFn } from './index'
+
+describe('useIntervalFn', () => {
+  let callback = vi.fn()
+
+  beforeEach(() => {
+    callback = vi.fn()
+  })
+
+  async function exec({ isActive, pause, resume }: Pausable) {
+    expect(isActive.value).toBeTruthy()
+    expect(callback).toHaveBeenCalledTimes(0)
+
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(1)
+
+    pause()
+    expect(isActive.value).toBeFalsy()
+
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(1)
+
+    resume()
+    expect(isActive.value).toBeTruthy()
+
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(2)
+  }
+
+  async function execImmediateCallback({ isActive, pause, resume }: Pausable) {
+    expect(isActive.value).toBeTruthy()
+    expect(callback).toHaveBeenCalledTimes(1)
+
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(2)
+
+    pause()
+    expect(isActive.value).toBeFalsy()
+
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(2)
+
+    resume()
+    expect(isActive.value).toBeTruthy()
+    expect(callback).toHaveBeenCalledTimes(3)
+
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(4)
+  }
+
+  it('basic pause/resume', async () => {
+    await exec(useIntervalFn(callback, 50))
+
+    callback = vi.fn()
+
+    const interval = ref(50)
+    await exec(useIntervalFn(callback, interval))
+
+    callback.mockClear()
+    interval.value = 20
+    await promiseTimeout(30)
+    expect(callback).toHaveBeenCalledTimes(1)
+  })
+
+  it('pause/resume with immediateCallback', async () => {
+    await execImmediateCallback(useIntervalFn(callback, 50, { immediateCallback: true }))
+
+    callback = vi.fn()
+
+    const interval = ref(50)
+    await execImmediateCallback(useIntervalFn(callback, interval, { immediateCallback: true }))
+
+    callback.mockClear()
+    interval.value = 20
+    await nextTick()
+    expect(callback).toHaveBeenCalledTimes(1)
+  })
+
+  it('pause/resume in scope', async () => {
+    const scope = effectScope()
+    await scope.run(async () => {
+      await exec(useIntervalFn(callback, 50))
+    })
+    callback.mockClear()
+    await scope.stop()
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(0)
+  })
+
+  it('cant work when interval is negative', async () => {
+    const { isActive } = useIntervalFn(callback, -1)
+
+    expect(isActive.value).toBeFalsy()
+    await promiseTimeout(60)
+    expect(callback).toHaveBeenCalledTimes(0)
+  })
+})