reedx/src/__tests__/propsFrom.js

Like redux but with less code

import React from 'react'
import { keys } from 'lodash'
import { createStore, combineReducers } from 'redux'
import { connect } from 'react-redux'
import { shallowWithStore } from 'enzyme-redux'

import model from '../model'
import propsFrom from '../propsFrom'
import pick from '../pick'
import omit from '../omit'

const state = 0
const counterA = model({ name: 'counterA', state })
const counterB = model({ name: 'counterB', state })

const Counter = ({ counter }) => (
  <div>{counter}</div>
)

test('state properties based on their selectors', () => {
  const store = createStore(combineReducers({ counterA, counterB }))
  const props = propsFrom(counterA, counterB)(store.getState())

  expect(props).toEqual({ counterA: 0, counterB: 0 })
})

test('map properties to a component using a redux connect()', () => {
  const store = createStore(combineReducers({ counterA, counterB }))
  const Component = connect(propsFrom(counterA, counterB))(Counter)
  const component = shallowWithStore(<Component />, store)

  expect(component.prop('counterA')).toEqual(state)
  expect(component.prop('counterB')).toEqual(state)
})

test('with computed properties', () => {
  const state = {
    all: [
      { id: 0, name: 'Peter' },
      { id: 1, name: 'John' }
    ],
    selectedId: 1
  }

  const computed = {
    user: ({ users }) => users.all.find(user => user.id === users.selectedId)
  }

  const users = model({ name: 'users', state, computed })
  const store = createStore(combineReducers({ users }))
  const props = propsFrom(users)(store.getState())

  expect(keys(props)).toEqual(['all', 'selectedId', 'user'])
  expect(props.user).toEqual({ id: 1, name: 'John' })
})

test('work with pick()', () => {
  const state = {
    a: 1,
    b: 2,
    c: 3
  }

  const test = model({ name: 'test', state })
  const store = createStore(combineReducers({ test }))
  const mapProps = propsFrom(
    pick(test, ['a:d', 'b'])
  )

  const Component = connect(mapProps)(Counter)
  const component = shallowWithStore(<Component />, store)

  expect(keys(component.props()).length).toBe(3)
  expect(component.prop('d')).toBe(1)
  expect(component.prop('b')).toBe(2)
})

test('work with omit()', () => {
  const state = {
    a: 1,
    b: 2,
    c: 3
  }

  const test = model({ name: 'test', state })
  const store = createStore(combineReducers({ test }))
  const mapProps = propsFrom(
    omit(test, ['a', 'b'])
  )

  const Component = connect(mapProps)(Counter)
  const component = shallowWithStore(<Component />, store)

  expect(keys(component.props()).length).toBe(2)
  expect(component.prop('c')).toBe(3)
})