feat: test case

Author: surmon-china

.github/workflows/publish.yml

@@ -22,7 +22,7 @@ jobs:
           cache: 'yarn'
           registry-url: https://registry.npmjs.org/
       - run: yarn install
-      # - run: yarn test
+      - run: yarn test
       - run: yarn rebirth
       - run: npm publish --access=public
         env:

README.md

@@ -243,7 +243,6 @@ yarn build
 
 ## TODO
 
-- [ ] test case
 - [ ] support `useEffect` deps with reactivity prop value
 
 ### Changelog

__tests__/watch.spec.ts

@@ -0,0 +1,5 @@
+/** @type {import('@ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'jsdom',
+}

jest.config.js

@@ -26,17 +26,11 @@
   "scripts": {
     "lint": "eslint --ext .ts src/**",
     "format": "prettier --write --parser typescript \"src/**/*.ts\"",
-    "test": "TODO",
+    "test": "jest",
     "build": "libundler",
-    "rebirth": "npm run lint && npm run build",
+    "rebirth": "npm run lint && npm run test && npm run build",
     "release": ". ./scripts/release.sh"
   },
-  "standard-version": {
-    "skip": {
-      "changelog": true,
-      "commit": true
-    }
-  },
   "peerDependencies": {
     "react": "^16.8",
     "react-dom": "^16.8"
@@ -45,17 +39,22 @@
     "@vue/reactivity": "^3.2.0-beta.5"
   },
   "devDependencies": {
-    "@surmon-china/libundler": "^1.0.1",
+    "@surmon-china/libundler": "^1.0.2",
+    "@testing-library/react": "^12.0.0",
+    "@testing-library/react-hooks": "^7.0.1",
+    "@types/jest": "^26.0.24",
     "@types/react": "^17.0.15",
     "@types/react-dom": "^17.0.9",
     "@typescript-eslint/eslint-plugin": "^4.28.4",
     "@typescript-eslint/parser": "^4.28.4",
     "eslint": "^7.31.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^3.4.0",
+    "jest": "^27.0.6",
     "prettier": "^2.3.2",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
+    "ts-jest": "^27.0.4",
     "typescript": "^4.3.5"
   }
 }

package.json

@@ -5,6 +5,6 @@ set -e
 PKG_VERSION=$(jq -r '.version' package.json)
 
 git fetch origin v"$PKG_VERSION" || {
-  npx standard-version -a --release-as "$PKG_VERSION"
+  npx standard-version --skip.changelog --skip.commit -a --release-as "$PKG_VERSION"
   git push --follow-tags origin main
 }

scripts/release.sh

@@ -3,24 +3,29 @@
  * @author Surmon <https://github.com/surmon-china>
  */
 
-import { useEffect } from 'react'
+import { useRef, useEffect } from 'react'
 
 export function onMounted(callback: () => any) {
   useEffect(() => {
     callback()
   }, [])
 }
 
-export function onBeforeUnmount(callback: () => void) {
+export function onUpdated(callback: () => void) {
+  const isMounted = useRef(false)
   useEffect(() => {
-    return () => {
+    if (isMounted.current) {
       callback()
+    } else {
+      isMounted.current = true
     }
-  }, [])
+  })
 }
 
-export function onUpdated(callback: () => void) {
+export function onBeforeUnmount(callback: () => void) {
   useEffect(() => {
-    callback()
-  })
+    return () => {
+      callback()
+    }
+  }, [])
 }

src/lifecycle.ts

@@ -6,52 +6,5 @@
 
 import type { Ref, UnwrapRef } from '@vue/reactivity'
 
+export * from '@vue/reactivity'
 export type ToRef<T> = [T] extends [Ref] ? T : Ref<UnwrapRef<T>>
-
-export {
-  computed,
-  customRef,
-  effect,
-  enableTracking,
-  isProxy,
-  isReactive,
-  isReadonly,
-  isRef,
-  ITERATE_KEY,
-  markRaw,
-  pauseTracking,
-  reactive,
-  readonly,
-  ref,
-  resetTracking,
-  shallowReactive,
-  shallowReadonly,
-  shallowRef,
-  stop,
-  toRaw,
-  toRef,
-  toRefs,
-  track,
-  trigger,
-  triggerRef,
-  unref,
-  ReactiveEffect,
-} from '@vue/reactivity'
-
-export type {
-  EffectScheduler,
-  DebuggerOptions,
-  ComputedGetter,
-  ComputedRef,
-  ComputedSetter,
-  DebuggerEvent,
-  DeepReadonly,
-  ReactiveEffectOptions,
-  Ref,
-  RefUnwrapBailTypes,
-  UnwrapNestedRefs,
-  ToRefs,
-  UnwrapRef,
-  WritableComputedOptions,
-  WritableComputedRef,
-} from '@vue/reactivity'

src/reactivity.ts

@@ -13,7 +13,7 @@ import { WATCH_CLEANUP_ERROR, WATCH_CALLBACK_ERROR } from './patch'
 
 export type WatchEffectOptions = DebuggerOptions
 export type WatchStopHandle = () => void
-export type InvalidateCallbackRegistrator = (cb: () => void) => void
+export type InvalidateCallbackRegistrator = (callback: () => void) => void
 export type WatchEffect = (onInvalidate: InvalidateCallbackRegistrator) => any
 
 /**

src/watch/watchEffect.ts

@@ -0,0 +1,72 @@
+import { renderHook, act } from '@testing-library/react-hooks'
+import * as vueReactivity from '@vue/reactivity'
+import * as veact from '../src'
+import {
+  onMounted,
+  onBeforeUnmount,
+  onUpdated,
+  useReactive,
+  useRef,
+  useShallowRef,
+  useShallowReactive,
+  useComputed,
+  watch,
+  useWatch,
+  watchEffect,
+  useWatchEffect,
+  useReactivity,
+  batchedUpdates,
+} from '../src'
+
+test('<exports> should be export all @vue/reactivity members', () => {
+  expect(
+    Object.keys(vueReactivity).every((key) => {
+      const targetMember = (veact as any)[key]
+      return Boolean(targetMember) && (vueReactivity as any)[key] === targetMember
+    })
+  ).toBeTruthy()
+})
+
+test('<type> should be function type', () => {
+  const hooksTargetType = 'function'
+  expect(typeof onMounted).toBe(hooksTargetType)
+  expect(typeof onUpdated).toBe(hooksTargetType)
+  expect(typeof onBeforeUnmount).toBe(hooksTargetType)
+  expect(typeof useReactive).toBe(hooksTargetType)
+  expect(typeof useRef).toBe(hooksTargetType)
+  expect(typeof useShallowRef).toBe(hooksTargetType)
+  expect(typeof useShallowReactive).toBe(hooksTargetType)
+  expect(typeof useComputed).toBe(hooksTargetType)
+  expect(typeof watch).toBe(hooksTargetType)
+  expect(typeof useWatch).toBe(hooksTargetType)
+  expect(typeof watchEffect).toBe(hooksTargetType)
+  expect(typeof useWatchEffect).toBe(hooksTargetType)
+  expect(typeof useReactivity).toBe(hooksTargetType)
+  expect(typeof batchedUpdates).toBe(hooksTargetType)
+})
+
+test('<lifecycle>', () => {
+  const results: string[] = []
+  const hookRenderer = renderHook(() => {
+    onMounted(() => {
+      results.push('onMounted')
+    })
+    onUpdated(() => {
+      results.push('onUpdated')
+    })
+    onBeforeUnmount(() => {
+      results.push('onBeforeUnmount')
+    })
+    return useRef(0)
+  })
+
+  act(() => {
+    hookRenderer.result.current.value++
+  })
+
+  hookRenderer.unmount()
+  expect(results.length).toBe(3)
+  expect(results[0]).toBe('onMounted')
+  expect(results[1]).toBe('onUpdated')
+  expect(results[2]).toBe('onBeforeUnmount')
+})