gopeeker 0.1.3

package/__tests__/provider.spec.tsx

@@ -0,0 +1,326 @@
+import React from 'react'
+import { render } from '@testing-library/react'
+import { act } from '@testing-library/react-hooks'
+import { createStore } from '../src/index'
+import { counter, counter2 } from './helper/model'
+import { createHook } from './helper/createHook'
+import { CounterWithRef } from './helper/CountFunctionComponent'
+import { Counter } from './helper/CountClassComponent'
+import {
+  CounterWithContextName,
+  CounterWithDefault,
+  CounterWithSameContextName,
+  CounterWithOtherContextName,
+} from './helper/MultiCountClassComponent'
+
+describe('Provider test', () => {
+  it('should render correct when use provider in component', () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, withProvider } = store
+
+    const Component: React.FC = () => <div></div>
+
+    expect(() => {
+      render(
+        <Provider>
+          <Component />
+        </Provider>
+      )
+    }).not.toThrow()
+
+    const WithProvider = withProvider(Component)
+
+    expect(() => {
+      render(<WithProvider />)
+    }).not.toThrow()
+  })
+
+  it('should throw error when call useModel without Provider wrapper', () => {
+    const originalError = console.error
+    console.error = jest.fn()
+
+    const store = createStore({
+      counter,
+    })
+    const { useModel } = store
+
+    const ErrorCounter: React.FC = () => {
+      const { state } = useModel('counter')
+      return <div>{state.count}</div>
+    }
+
+    expect(() => render(<ErrorCounter />)).toThrow()
+
+    console.error = originalError
+  })
+
+  it('support pass ref use withProviderForwardRef', () => {
+    let ref: any
+    render(<CounterWithRef ref={r => (ref = r)} />)
+
+    expect(ref.methodFromUseImperativeHandle).toBeDefined()
+  })
+
+  it('should add the store to function component context', () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, useModel } = store
+
+    const {
+      result: { current },
+    } = createHook(Provider, useModel, 'counter')
+
+    expect(current.state.count).toBe(0)
+    expect(current.reducers).toBeDefined()
+    expect(current.effects).toBeDefined()
+  })
+
+  it('should add the store to class component context', () => {
+    const originalWarn = console.warn
+    console.warn = jest.fn()
+
+    const store = createStore({
+      counter,
+    })
+    const { Provider, withModel } = store
+
+    const Component = withModel('counter')(Counter)
+
+    const wrapper = render(
+      <Provider>
+        <Component />
+      </Provider>
+    )
+
+    expect(wrapper.getByTestId('count').innerHTML).toBe('0')
+
+    const Component2 = withModel('counter', undefined, 'models')(CounterWithSameContextName)
+    const wrapper2 = render(
+      <Provider>
+        {/* @ts-ignore */}
+        <Component2 models="what ever" />
+      </Provider>
+    )
+    expect(console.warn).toHaveBeenCalledWith(
+      'IMPORT MODEL FAILED: The component wrapped by [withModel] already has "models" in its props.'
+    )
+    expect(wrapper2.getByTestId('show-models').innerHTML).toBe('what ever')
+
+    const Component3 = withModel('counter')(Counter)
+
+    render(
+      <Provider>
+        {/* @ts-ignore */}
+        <Component3 state="1" reducers="2" effects="3" />
+      </Provider>
+    )
+    expect(console.warn).toHaveBeenCalledWith(
+      'IMPORT MODEL FAILED: The component wrapped by [withModel] already has "state" in its props.'
+    )
+    expect(console.warn).toHaveBeenCalledWith(
+      'IMPORT MODEL FAILED: The component wrapped by [withModel] already has "reducers" in its props.'
+    )
+    expect(console.warn).toHaveBeenCalledWith(
+      'IMPORT MODEL FAILED: The component wrapped by [withModel] already has "effects" in its props.'
+    )
+
+    const Component4 = withModel('counter', undefined, 'myModel')(CounterWithOtherContextName)
+    const wrapper4 = render(
+      <Provider>
+        {/* @ts-ignore */}
+        <Component4 myProp="what ever" />
+      </Provider>
+    )
+    expect(wrapper4.getByTestId('show-myProp').innerHTML).toBe('what ever')
+    expect(wrapper4.getByTestId('show-myModel').innerHTML).toBe('0')
+
+    console.warn = originalWarn
+  })
+
+  it('should warning when props override', () => {
+    const originalWarn = console.warn
+    console.warn = jest.fn()
+
+    const store = createStore({
+      counter,
+    })
+    const { Provider, withModel } = store
+
+    const Component = withModel('counter')(Counter)
+
+    const wrapper = render(
+      <Provider>
+        <Component />
+      </Provider>
+    )
+
+    expect(wrapper.getByTestId('count').innerHTML).toBe('0')
+
+    const Component2 = withModel('counter', undefined, 'models')(CounterWithSameContextName)
+    const wrapper2 = render(
+      <Provider>
+        {/* @ts-ignore */}
+        <Component2 models="what ever" />
+      </Provider>
+    )
+    expect(console.warn).toHaveBeenCalledWith(
+      'IMPORT MODEL FAILED: The component wrapped by [withModel] already has "models" in its props.'
+    )
+    expect(wrapper2.getByTestId('show-models').innerHTML).toBe('what ever')
+
+    const Component3 = withModel('counter', undefined, 'myModel')(CounterWithOtherContextName)
+    const wrapper3 = render(
+      <Provider>
+        {/* @ts-ignore */}
+        <Component3 myProp="what ever" />
+      </Provider>
+    )
+    expect(wrapper3.getByTestId('show-myProp').innerHTML).toBe('what ever')
+    expect(wrapper3.getByTestId('show-myModel').innerHTML).toBe('0')
+
+    console.warn = originalWarn
+  })
+
+  it('should add specific stores to class component context', () => {
+    const store = createStore({
+      counter,
+      counter2,
+    })
+    const { Provider, withModels } = store
+
+    const Component2 = withModels(['counter', 'counter2'])(CounterWithDefault)
+
+    const wrapper2 = render(
+      <Provider>
+        <Component2 />
+      </Provider>
+    )
+    expect(wrapper2.getByTestId('count-1').innerHTML).toBe('0')
+    expect(wrapper2.getByTestId('count-2').innerHTML).toBe('0')
+  })
+
+  it('should add specific stores to class component context with custom property', () => {
+    const originalWarn = console.warn
+    console.warn = jest.fn()
+
+    const store = createStore({
+      counter,
+      counter2,
+    })
+    const { Provider, withModels } = store
+
+    const Component = withModels(
+      ['counter', 'counter2'],
+      {
+        counter: state => ({
+          count: state.count,
+        }),
+      },
+      'forDobux'
+    )(CounterWithContextName)
+
+    const wrapper = render(
+      <Provider>
+        <Component />
+      </Provider>
+    )
+    expect(wrapper.getByTestId('count-1').innerHTML).toBe('0')
+    expect(wrapper.getByTestId('count-2').innerHTML).toBe('0')
+
+    const Component2 = withModels(['counter', 'counter2'])(CounterWithSameContextName)
+
+    const wrapper2 = render(
+      <Provider>
+        {/* @ts-ignore */}
+        <Component2 models="correct answer" />
+      </Provider>
+    )
+
+    expect(console.warn).toHaveBeenCalledWith(
+      'IMPORT MODELS FAILED: The component wrapped by [withModels] already has "models" in its props.'
+    )
+    expect(wrapper2.getByTestId('show-models').innerHTML).toBe('correct answer')
+
+    console.warn = originalWarn
+  })
+
+  it('should not reset store when component unmount', async () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, useModel } = store
+    const { result, unmount } = createHook(Provider, useModel, 'counter')
+
+    act(() => {
+      expect(result.current.state.count).toBe(0)
+      result.current.reducers.increase()
+    })
+
+    expect(result.current.state.count).toBe(1)
+
+    unmount()
+
+    const {
+      result: { current },
+    } = createHook(Provider, useModel, 'counter')
+
+    expect(current.state.count).toBe(1)
+  })
+
+  it('setting autoReset to true, model should be reset when the component unmount', async () => {
+    const store = createStore(
+      {
+        counter,
+      },
+      {
+        autoReset: true,
+      }
+    )
+    const { Provider, useModel } = store
+    const { result, unmount } = createHook(Provider, useModel, 'counter')
+
+    act(() => {
+      expect(result.current.state.count).toBe(0)
+      result.current.reducers.increase()
+    })
+
+    expect(result.current.state.count).toBe(1)
+
+    unmount()
+
+    const {
+      result: { current },
+    } = createHook(Provider, useModel, 'counter')
+
+    expect(current.state.count).toBe(0)
+  })
+
+  it('setting autoReset to specify model, should be reset when the component unmount', async () => {
+    const store = createStore(
+      {
+        counter,
+      },
+      {
+        autoReset: ['counter'],
+      }
+    )
+    const { Provider, useModel } = store
+    const { result, unmount } = createHook(Provider, useModel, 'counter')
+
+    act(() => {
+      expect(result.current.state.count).toBe(0)
+      result.current.reducers.increase()
+    })
+
+    expect(result.current.state.count).toBe(1)
+
+    unmount()
+
+    const hook = createHook(Provider, useModel, 'counter')
+
+    expect(hook.result.current.state.count).toBe(0)
+  })
+})

package/__tests__/reducer.spec.ts

@@ -0,0 +1,270 @@
+import { act } from '@testing-library/react-hooks'
+import { createStore } from '../src/index'
+import { counter } from './helper/model'
+import { createHook } from './helper/createHook'
+
+describe('reducer test', () => {
+  it('customize reducers execution results should be as expected', () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, useModel } = store
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    const increase = result.current.reducers.increase
+    const decrease = result.current.reducers.decrease
+
+    expect(increase.length).toBe(0)
+
+    act(() => {
+      increase()
+    })
+    expect(result.current.state.count).toBe(1)
+
+    act(() => {
+      decrease()
+    })
+    expect(result.current.state.count).toBe(0)
+  })
+
+  it('should not rerender when the value of mapStateToProps returned not modified', () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, useModel } = store
+
+    const { result } = createHook(Provider, useModel, 'counter', (state: any) => {
+      return {
+        count: state.count,
+      }
+    })
+
+    const increase = result.current.reducers.increase
+    const decrease = result.current.reducers.decrease
+
+    expect(result.current.state.count).toBe(0)
+    expect(result.current.state.data).toBeUndefined()
+    expect(increase.length).toBe(0)
+
+    act(() => {
+      increase()
+    })
+    expect(result.current.state.count).toBe(1)
+
+    act(() => {
+      decrease()
+    })
+    expect(result.current.state.count).toBe(0)
+
+    act(() => {
+      result.current.reducers.setValue('data', 1)
+    })
+
+    expect(result.current.state.data).toBeUndefined()
+  })
+
+  it('should provider build-in reducers when no customize passed', () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, useModel } = store
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    const setValue = result.current.reducers.setValue
+    const setValues = result.current.reducers.setValues
+    const reset = result.current.reducers.reset
+
+    expect(setValue.length).toBe(2)
+    act(() => {
+      setValue('count', 1)
+    })
+    expect(result.current.state.count).toBe(1)
+
+    act(() => {
+      setValue('count', (prevState: number) => {
+        return prevState - 1
+      })
+    })
+    expect(result.current.state.count).toBe(0)
+
+    act(() => {
+      setValue('data', (draft: any) => {
+        draft.a = 2
+        draft.b = '3'
+      })
+    })
+    expect(result.current.state.data).toEqual({
+      a: 2,
+      b: '3',
+    })
+
+    expect(setValues.length).toBe(1)
+    act(() => {
+      setValues({
+        count: 10,
+      })
+    })
+    expect(result.current.state.count).toBe(10)
+
+    act(() => {
+      setValues((prevState: Record<string, any>) => {
+        prevState.count = prevState.count - 10
+      })
+    })
+    expect(result.current.state.count).toBe(0)
+
+    act(() => {
+      setValues((prevState: Record<string, any>) => {
+        return {
+          count: prevState.count + 1,
+        }
+      })
+    })
+    expect(result.current.state.count).toBe(1)
+
+    expect(reset.length).toBe(1)
+    act(() => {
+      reset('count')
+    })
+    expect(result.current.state.count).toBe(0)
+
+    act(() => {
+      setValues({
+        data: 1,
+        count: 10,
+      })
+    })
+
+    expect(result.current.state.count).toBe(10)
+    expect(result.current.state.data).toBe(1)
+
+    act(() => {
+      reset()
+    })
+
+    expect(result.current.state.count).toBe(0)
+    expect(result.current.state.data).toEqual({
+      a: 1,
+      b: '2',
+    })
+  })
+
+  it('should provider build-in reducers when no customize passed', () => {
+    const store = createStore({
+      counter,
+    })
+    const { Provider, useModel } = store
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    const setValue = result.current.reducers.setValue
+    const setValues = result.current.reducers.setValues
+    const reset = result.current.reducers.reset
+
+    expect(setValue.length).toBe(2)
+    act(() => {
+      setValue('count', 1)
+    })
+    expect(result.current.state.count).toBe(1)
+
+    act(() => {
+      setValue('count', (prevState: number) => {
+        return prevState - 1
+      })
+    })
+    expect(result.current.state.count).toBe(0)
+
+    expect(setValues.length).toBe(1)
+    act(() => {
+      setValues({
+        count: 10,
+      })
+    })
+    expect(result.current.state.count).toBe(10)
+
+    act(() => {
+      setValues((prevState: Record<string, any>) => {
+        prevState.count = prevState.count - 10
+      })
+    })
+    expect(result.current.state.count).toBe(0)
+
+    expect(reset.length).toBe(1)
+    act(() => {
+      reset('count')
+    })
+    expect(result.current.state.count).toBe(0)
+
+    act(() => {
+      setValues({
+        data: 1,
+        count: 10,
+      })
+    })
+
+    expect(result.current.state.count).toBe(10)
+    expect(result.current.state.data).toBe(1)
+
+    act(() => {
+      reset()
+    })
+
+    expect(result.current.state.count).toBe(0)
+    expect(result.current.state.data).toEqual({
+      a: 1,
+      b: '2',
+    })
+  })
+
+  it('should overwrite build-in reducers when customize passed', () => {
+    const store = createStore({
+      counter: {
+        state: {
+          count: 10,
+        },
+        reducers: {
+          setValue(state, payload) {
+            state.count = payload + 1
+          },
+
+          setValues(state, partialState) {
+            Object.keys(partialState).forEach(key => {
+              state[key] = partialState[key] + 1
+            })
+          },
+
+          reset(state) {
+            state.count = 10
+          },
+        },
+        effects: () => ({}),
+      },
+    })
+    const { Provider, useModel } = store
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    const setValue = result.current.reducers.setValue
+    const setValues = result.current.reducers.setValues
+    const reset = result.current.reducers.reset
+
+    act(() => {
+      setValue(1)
+    })
+    expect(result.current.state.count).toBe(2)
+
+    act(() => {
+      setValues({
+        count: 10,
+      })
+    })
+    expect(result.current.state.count).toBe(11)
+
+    act(() => {
+      reset()
+    })
+    expect(result.current.state.count).toBe(10)
+  })
+})

package/__tests__/store.spec.ts

@@ -0,0 +1,113 @@
+import { act } from '@testing-library/react-hooks'
+import { createModel } from '../src'
+import { Store } from '../src/core/Store'
+import { createHook } from './helper/createHook'
+import { defaultStoreOptions } from './helper/shared'
+
+const store = new Store(
+  {
+    test: createModel()({
+      state: {
+        count: 1,
+      },
+    }),
+  },
+  defaultStoreOptions
+)
+
+describe('Store test', () => {
+  it('Store should be defined', () => {
+    expect(Store).toBeDefined()
+    expect(Store.prototype.constructor).toBe(Store)
+  })
+
+  it('should have valid api', () => {
+    const methods = Object.keys(store)
+
+    expect(methods).toContain('Provider')
+    expect(methods).toContain('withProvider')
+    expect(methods).toContain('withProviderForwardRef')
+    expect(methods).toContain('useModel')
+    expect(methods).toContain('withModel')
+    expect(methods).toContain('withModels')
+    expect(methods).toContain('getState')
+    expect(methods).toContain('getReducers')
+  })
+
+  it('state can be primitive value', () => {
+    const { Provider, useModel } = new Store(
+      {
+        counter: {
+          state: 1,
+          reducers: {
+            increase() {
+              return 2
+            },
+          },
+          effects: () => ({}),
+        },
+      },
+      defaultStoreOptions
+    )
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    expect(result.current.state).toBe(1)
+
+    act(() => {
+      result.current.reducers.increase()
+    })
+
+    expect(result.current.state).toBe(2)
+  })
+
+  it('state can be array', () => {
+    const { Provider, useModel } = new Store(
+      {
+        counter: {
+          state: [1, 2, 3],
+          reducers: {
+            increase() {
+              return 2
+            },
+          },
+          effects: () => ({}),
+        },
+      },
+      defaultStoreOptions
+    )
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    expect(result.current.state).toEqual([1, 2, 3])
+  })
+
+  it('state can be object', () => {
+    const { Provider, useModel } = new Store(
+      {
+        counter: {
+          state: {
+            count: 1,
+          },
+          reducers: {
+            increase(state) {
+              state.count += 1
+            },
+          },
+          effects: () => ({}),
+        },
+      },
+      defaultStoreOptions
+    )
+
+    const { result } = createHook(Provider, useModel, 'counter')
+
+    expect(result.current.state.count).toBe(1)
+
+    act(() => {
+      result.current.reducers.increase()
+    })
+
+    expect(result.current.state.count).toBe(2)
+  })
+})