Split up unit test files

Author: markerikson

test/autotrackMemoize.spec.ts

@@ -0,0 +1,216 @@
+import { createSelectorCreator, autotrackMemoize } from 'reselect'
+
+// Construct 1E6 states for perf test outside of the perf test so as to not change the execute time of the test function
+const numOfStates = 1000000
+interface StateA {
+  a: number
+}
+
+interface StateAB {
+  a: number
+  b: number
+}
+
+interface StateSub {
+  sub: {
+    a: number
+  }
+}
+
+const states: StateAB[] = []
+
+for (let i = 0; i < numOfStates; i++) {
+  states.push({ a: 1, b: 2 })
+}
+
+describe('Basic selector behavior with autotrack', () => {
+  const createSelector = createSelectorCreator(autotrackMemoize)
+
+  test('basic selector', () => {
+    // console.log('Selector test')
+    const selector = createSelector(
+      (state: StateA) => state.a,
+      a => a
+    )
+    const firstState = { a: 1 }
+    const firstStateNewPointer = { a: 1 }
+    const secondState = { a: 2 }
+
+    expect(selector(firstState)).toBe(1)
+    expect(selector(firstState)).toBe(1)
+    expect(selector.recomputations()).toBe(1)
+    expect(selector(firstStateNewPointer)).toBe(1)
+    expect(selector.recomputations()).toBe(1)
+    expect(selector(secondState)).toBe(2)
+    expect(selector.recomputations()).toBe(2)
+  })
+
+  test("don't pass extra parameters to inputSelector when only called with the state", () => {
+    const selector = createSelector(
+      (...params: any[]) => params.length,
+      a => a
+    )
+    expect(selector({})).toBe(1)
+  })
+
+  test('basic selector multiple keys', () => {
+    const selector = createSelector(
+      (state: StateAB) => state.a,
+      (state: StateAB) => state.b,
+      (a, b) => a + b
+    )
+    const state1 = { a: 1, b: 2 }
+    expect(selector(state1)).toBe(3)
+    expect(selector(state1)).toBe(3)
+    expect(selector.recomputations()).toBe(1)
+    const state2 = { a: 3, b: 2 }
+    expect(selector(state2)).toBe(5)
+    expect(selector(state2)).toBe(5)
+    expect(selector.recomputations()).toBe(2)
+  })
+
+  test('basic selector invalid input selector', () => {
+    expect(() =>
+      createSelector(
+        // @ts-ignore
+        (state: StateAB) => state.a,
+        function input2(state: StateAB) {
+          return state.b
+        },
+        'not a function',
+        (a: any, b: any) => a + b
+      )
+    ).toThrow(
+      'createSelector expects all input-selectors to be functions, but received the following types: [function unnamed(), function input2(), string]'
+    )
+
+    expect(() =>
+      // @ts-ignore
+      createSelector((state: StateAB) => state.a, 'not a function')
+    ).toThrow(
+      'createSelector expects an output function after the inputs, but received: [string]'
+    )
+  })
+
+  test('basic selector cache hit performance', () => {
+    if (process.env.COVERAGE) {
+      return // don't run performance tests for coverage
+    }
+
+    const selector = createSelector(
+      (state: StateAB) => state.a,
+      (state: StateAB) => state.b,
+      (a, b) => a + b
+    )
+    const state1 = { a: 1, b: 2 }
+
+    const start = performance.now()
+    for (let i = 0; i < 1000000; i++) {
+      selector(state1)
+    }
+    const totalTime = performance.now() - start
+
+    expect(selector(state1)).toBe(3)
+    expect(selector.recomputations()).toBe(1)
+    // Expected a million calls to a selector with the same arguments to take less than 1 second
+    expect(totalTime).toBeLessThan(1000)
+  })
+
+  test('basic selector cache hit performance for state changes but shallowly equal selector args', () => {
+    if (process.env.COVERAGE) {
+      return // don't run performance tests for coverage
+    }
+
+    const selector = createSelector(
+      (state: StateAB) => state.a,
+      (state: StateAB) => state.b,
+      (a, b) => a + b
+    )
+
+    const start = performance.now()
+    for (let i = 0; i < 1000000; i++) {
+      selector(states[i])
+    }
+    const totalTime = performance.now() - start
+
+    expect(selector(states[0])).toBe(3)
+    expect(selector.recomputations()).toBe(1)
+
+    // Expected a million calls to a selector with the same arguments to take less than 1 second
+    expect(totalTime).toBeLessThan(1000)
+  })
+
+  test('memoized composite arguments', () => {
+    const selector = createSelector(
+      (state: StateSub) => state.sub,
+      sub => sub.a
+    )
+    const state1 = { sub: { a: 1 } }
+    expect(selector(state1)).toEqual(1)
+    expect(selector(state1)).toEqual(1)
+    expect(selector.recomputations()).toBe(1)
+    const state2 = { sub: { a: 2 } }
+    expect(selector(state2)).toEqual(2)
+    expect(selector.recomputations()).toBe(2)
+  })
+
+  test('first argument can be an array', () => {
+    const selector = createSelector(
+      [state => state.a, state => state.b],
+      (a, b) => {
+        return a + b
+      }
+    )
+    expect(selector({ a: 1, b: 2 })).toBe(3)
+    expect(selector({ a: 1, b: 2 })).toBe(3)
+    expect(selector.recomputations()).toBe(1)
+    expect(selector({ a: 3, b: 2 })).toBe(5)
+    expect(selector.recomputations()).toBe(2)
+  })
+
+  test('can accept props', () => {
+    let called = 0
+    const selector = createSelector(
+      (state: StateAB) => state.a,
+      (state: StateAB) => state.b,
+      (state: StateAB, props: { c: number }) => props.c,
+      (a, b, c) => {
+        called++
+        return a + b + c
+      }
+    )
+    expect(selector({ a: 1, b: 2 }, { c: 100 })).toBe(103)
+  })
+
+  test('recomputes result after exception', () => {
+    let called = 0
+    const selector = createSelector(
+      (state: StateA) => state.a,
+      () => {
+        called++
+        throw Error('test error')
+      }
+    )
+    expect(() => selector({ a: 1 })).toThrow('test error')
+    expect(() => selector({ a: 1 })).toThrow('test error')
+    expect(called).toBe(2)
+  })
+
+  test('memoizes previous result before exception', () => {
+    let called = 0
+    const selector = createSelector(
+      (state: StateA) => state.a,
+      a => {
+        called++
+        if (a > 1) throw Error('test error')
+        return a
+      }
+    )
+    const state1 = { a: 1 }
+    const state2 = { a: 2 }
+    expect(selector(state1)).toBe(1)
+    expect(() => selector(state2)).toThrow('test error')
+    expect(selector(state1)).toBe(1)
+    expect(called).toBe(2)
+  })
+})

test/createStructuredSelector.spec.ts

@@ -0,0 +1,62 @@
+import {
+  createSelectorCreator,
+  defaultMemoize,
+  createStructuredSelector
+} from 'reselect'
+
+interface StateAB {
+  a: number
+  b: number
+}
+
+describe('createStructureSelector', () => {
+  test('structured selector', () => {
+    const selector = createStructuredSelector({
+      x: (state: StateAB) => state.a,
+      y: (state: StateAB) => state.b
+    })
+    const firstResult = selector({ a: 1, b: 2 })
+    expect(firstResult).toEqual({ x: 1, y: 2 })
+    expect(selector({ a: 1, b: 2 })).toBe(firstResult)
+    const secondResult = selector({ a: 2, b: 2 })
+    expect(secondResult).toEqual({ x: 2, y: 2 })
+    expect(selector({ a: 2, b: 2 })).toBe(secondResult)
+  })
+
+  test('structured selector with invalid arguments', () => {
+    expect(() =>
+      // @ts-expect-error
+      createStructuredSelector(
+        (state: StateAB) => state.a,
+        (state: StateAB) => state.b
+      )
+    ).toThrow(/expects first argument to be an object.*function/)
+    expect(() =>
+      createStructuredSelector({
+        a: state => state.b,
+        // @ts-expect-error
+        c: 'd'
+      })
+    ).toThrow(
+      'createSelector expects all input-selectors to be functions, but received the following types: [function a(), string]'
+    )
+  })
+
+  test('structured selector with custom selector creator', () => {
+    const customSelectorCreator = createSelectorCreator(
+      defaultMemoize,
+      (a, b) => a === b
+    )
+    const selector = createStructuredSelector(
+      {
+        x: (state: StateAB) => state.a,
+        y: (state: StateAB) => state.b
+      },
+      customSelectorCreator
+    )
+    const firstResult = selector({ a: 1, b: 2 })
+    expect(firstResult).toEqual({ x: 1, y: 2 })
+    expect(selector({ a: 1, b: 2 })).toBe(firstResult)
+    expect(selector({ a: 2, b: 2 })).toEqual({ x: 2, y: 2 })
+  })
+})