Add tests for lruMemoize and resultEqualityCheck integration

  - Added runtime unit tests to verify that:
    - `resultEqualityCheck` works correctly when set to `shallowEqual`.
    - `resultEqualityCheck` is not called on the first output selector call.
    - `lruMemoize` with `resultEqualityCheck` set to `referenceEqualityCheck` works the same as `lruMemoize` without `resultEqualityCheck`.

Author: aryaemami59

test/lruMemoize.test.ts

@@ -1,9 +1,15 @@
 // TODO: Add test for React Redux connect function
 
-import { createSelectorCreator, lruMemoize } from 'reselect'
-import { vi } from 'vitest'
-
-const createSelector = createSelectorCreator({
+import { shallowEqual } from 'react-redux'
+import {
+  createSelectorCreator,
+  lruMemoize,
+  referenceEqualityCheck
+} from 'reselect'
+import type { RootState } from './testUtils'
+import { localTest, toggleCompleted } from './testUtils'
+
+const createSelectorLru = createSelectorCreator({
   memoize: lruMemoize,
   argsMemoize: lruMemoize
 })
@@ -268,7 +274,7 @@ describe(lruMemoize, () => {
 
     const fooChangeSpy = vi.fn()
 
-    const fooChangeHandler = createSelector(
+    const fooChangeHandler = createSelectorLru(
       (state: any) => state.foo,
       fooChangeSpy
     )
@@ -284,7 +290,7 @@ describe(lruMemoize, () => {
     const state2 = { a: 1 }
     let count = 0
 
-    const selector = createSelector([(state: any) => state.a], () => {
+    const selector = createSelectorLru([(state: any) => state.a], () => {
       count++
       return undefined
     })
@@ -361,7 +367,7 @@ describe(lruMemoize, () => {
     funcCalls = 0
 
     // Test out maxSize of 3 + exposure via createSelector
-    const selector = createSelector(
+    const selector = createSelectorLru(
       (state: string) => state,
       state => {
         funcCalls++
@@ -415,3 +421,134 @@ describe(lruMemoize, () => {
     expect(selector.resultFunc.clearCache).toBeUndefined()
   })
 })
+
+describe('lruMemoize integration with resultEqualityCheck', () => {
+  const createAppSelector = createSelectorLru.withTypes<RootState>()
+
+  const resultEqualityCheck = vi
+    .fn(shallowEqual)
+    .mockName('resultEqualityCheck')
+
+  afterEach(() => {
+    resultEqualityCheck.mockClear()
+  })
+
+  localTest(
+    'resultEqualityCheck works when set to shallowEqual',
+    ({ store }) => {
+      const selectTodoIds = lruMemoize(
+        (state: RootState) => state.todos.map(({ id }) => id),
+        { resultEqualityCheck }
+      )
+
+      const firstResult = selectTodoIds(store.getState())
+
+      store.dispatch(toggleCompleted(0))
+
+      const secondResult = selectTodoIds(store.getState())
+
+      expect(firstResult).toBe(secondResult)
+
+      expect(selectTodoIds.resultsCount()).toBe(1)
+    }
+  )
+
+  localTest(
+    'resultEqualityCheck should not be called on the first output selector call',
+    ({ store }) => {
+      const selectTodoIds = createAppSelector(
+        [state => state.todos],
+        todos => todos.map(({ id }) => id),
+        {
+          memoizeOptions: { resultEqualityCheck },
+          devModeChecks: { inputStabilityCheck: 'once' }
+        }
+      )
+
+      expect(selectTodoIds(store.getState())).to.be.an('array').that.is.not
+        .empty
+
+      expect(resultEqualityCheck).not.toHaveBeenCalled()
+
+      store.dispatch(toggleCompleted(0))
+
+      expect(selectTodoIds.lastResult()).toBe(selectTodoIds(store.getState()))
+
+      expect(resultEqualityCheck).toHaveBeenCalledOnce()
+
+      expect(selectTodoIds.memoizedResultFunc.resultsCount()).toBe(1)
+
+      expect(selectTodoIds.recomputations()).toBe(2)
+
+      expect(selectTodoIds.resultsCount()).toBe(2)
+
+      expect(selectTodoIds.dependencyRecomputations()).toBe(2)
+
+      store.dispatch(toggleCompleted(0))
+
+      expect(selectTodoIds.lastResult()).toBe(selectTodoIds(store.getState()))
+
+      expect(resultEqualityCheck).toHaveBeenCalledTimes(2)
+
+      expect(selectTodoIds.memoizedResultFunc.resultsCount()).toBe(1)
+
+      expect(selectTodoIds.recomputations()).toBe(3)
+
+      expect(selectTodoIds.resultsCount()).toBe(3)
+
+      expect(selectTodoIds.dependencyRecomputations()).toBe(3)
+    }
+  )
+
+  localTest(
+    'lruMemoize with resultEqualityCheck set to referenceEqualityCheck works the same as lruMemoize without resultEqualityCheck',
+    ({ store }) => {
+      const resultEqualityCheck = vi
+        .fn(referenceEqualityCheck)
+        .mockName('resultEqualityCheck')
+
+      const selectTodoIdsWithResultEqualityCheck = lruMemoize(
+        (state: RootState) => state.todos.map(({ id }) => id),
+        { resultEqualityCheck }
+      )
+
+      const firstResultWithResultEqualityCheck =
+        selectTodoIdsWithResultEqualityCheck(store.getState())
+
+      expect(resultEqualityCheck).not.toHaveBeenCalled()
+
+      store.dispatch(toggleCompleted(0))
+
+      const secondResultWithResultEqualityCheck =
+        selectTodoIdsWithResultEqualityCheck(store.getState())
+
+      expect(firstResultWithResultEqualityCheck).not.toBe(
+        secondResultWithResultEqualityCheck
+      )
+
+      expect(firstResultWithResultEqualityCheck).toStrictEqual(
+        secondResultWithResultEqualityCheck
+      )
+
+      expect(selectTodoIdsWithResultEqualityCheck.resultsCount()).toBe(2)
+
+      const selectTodoIds = lruMemoize((state: RootState) =>
+        state.todos.map(({ id }) => id)
+      )
+
+      const firstResult = selectTodoIds(store.getState())
+
+      store.dispatch(toggleCompleted(0))
+
+      const secondResult = selectTodoIds(store.getState())
+
+      expect(firstResult).not.toBe(secondResult)
+
+      expect(firstResult).toStrictEqual(secondResult)
+
+      expect(selectTodoIds.resultsCount()).toBe(2)
+
+      resultEqualityCheck.mockClear()
+    }
+  )
+})