Add test for subscription serialization

Author: markerikson

packages/toolkit/src/query/tests/buildMiddleware.test.tsx

@@ -26,11 +26,13 @@ const api = createApi({
       providesTags: ['Bread'],
     }),
     invalidateFruit: build.mutation({
-      query: (fruit?: 'Banana' | 'Bread' | null) => ({ url: `invalidate/fruit/${fruit || ''}` }),
+      query: (fruit?: 'Banana' | 'Bread' | null) => ({
+        url: `invalidate/fruit/${fruit || ''}`,
+      }),
       invalidatesTags(result, error, arg) {
         return [arg]
-      }
-    })
+      },
+    }),
   }),
 })
 const { getBanana, getBread, invalidateFruit } = api.endpoints
@@ -77,9 +79,11 @@ it('invalidates the specified tags', async () => {
   )
 })
 
-it('invalidates tags correctly when null or undefined are provided as tags', async() =>{
+it('invalidates tags correctly when null or undefined are provided as tags', async () => {
   await storeRef.store.dispatch(getBanana.initiate(1))
-  await storeRef.store.dispatch(api.util.invalidateTags([undefined, null, 'Banana']))
+  await storeRef.store.dispatch(
+    api.util.invalidateTags([undefined, null, 'Banana']),
+  )
 
   // Slight pause to let the middleware run and such
   await delay(20)
@@ -96,41 +100,116 @@ it('invalidates tags correctly when null or undefined are provided as tags', asy
   expect(storeRef.store.getState().actions).toMatchSequence(...apiActions)
 })
 
-
 it.each([
-  { tags: [undefined, null, 'Bread'] as Parameters<typeof api.util.invalidateTags>['0'] },
-  { tags: [undefined, null], }, { tags: [] }]
-)('does not invalidate with tags=$tags if no query matches', async ({ tags }) => {
-  await storeRef.store.dispatch(getBanana.initiate(1))
-  await storeRef.store.dispatch(api.util.invalidateTags(tags))
+  {
+    tags: [undefined, null, 'Bread'] as Parameters<
+      typeof api.util.invalidateTags
+    >['0'],
+  },
+  { tags: [undefined, null] },
+  { tags: [] },
+])(
+  'does not invalidate with tags=$tags if no query matches',
+  async ({ tags }) => {
+    await storeRef.store.dispatch(getBanana.initiate(1))
+    await storeRef.store.dispatch(api.util.invalidateTags(tags))
+
+    // Slight pause to let the middleware run and such
+    await delay(20)
+
+    const apiActions = [
+      api.internalActions.middlewareRegistered.match,
+      getBanana.matchPending,
+      getBanana.matchFulfilled,
+      api.util.invalidateTags.match,
+    ]
+
+    expect(storeRef.store.getState().actions).toMatchSequence(...apiActions)
+  },
+)
 
-  // Slight pause to let the middleware run and such
-  await delay(20)
+it.each([
+  { mutationArg: 'Bread' as 'Bread' | null | undefined },
+  { mutationArg: undefined },
+  { mutationArg: null },
+])(
+  'does not invalidate queries when a mutation with tags=[$mutationArg] runs and does not match anything',
+  async ({ mutationArg }) => {
+    await storeRef.store.dispatch(getBanana.initiate(1))
+    await storeRef.store.dispatch(invalidateFruit.initiate(mutationArg))
+
+    // Slight pause to let the middleware run and such
+    await delay(20)
+
+    const apiActions = [
+      api.internalActions.middlewareRegistered.match,
+      getBanana.matchPending,
+      getBanana.matchFulfilled,
+      invalidateFruit.matchPending,
+      invalidateFruit.matchFulfilled,
+    ]
+
+    expect(storeRef.store.getState().actions).toMatchSequence(...apiActions)
+  },
+)
+
+it('correctly stringifies subscription state and dispatches subscriptionsUpdated', async () => {
+  // Create a fresh store for this test to avoid interference
+  const testStoreRef = setupApiStore(
+    api,
+    {
+      ...actionsReducer,
+    },
+    { withoutListeners: true },
+  )
 
-  const apiActions = [
-    api.internalActions.middlewareRegistered.match,
-    getBanana.matchPending,
-    getBanana.matchFulfilled,
-    api.util.invalidateTags.match,
-  ]
+  // Start multiple subscriptions
+  const subscription1 = testStoreRef.store.dispatch(
+    getBanana.initiate(1, {
+      subscriptionOptions: { pollingInterval: 1000 },
+    }),
+  )
+  const subscription2 = testStoreRef.store.dispatch(
+    getBanana.initiate(2, {
+      subscriptionOptions: { refetchOnFocus: true },
+    }),
+  )
+  const subscription3 = testStoreRef.store.dispatch(
+    api.endpoints.getBananas.initiate(),
+  )
 
-  expect(storeRef.store.getState().actions).toMatchSequence(...apiActions)
+  // Wait for the subscriptions to be established
+  await Promise.all([subscription1, subscription2, subscription3])
+
+  // Wait for the subscription sync timer (500ms + buffer)
+  await delay(600)
+
+  // Check the final subscription state in the store
+  const finalState = testStoreRef.store.getState()
+  const subscriptionState = finalState[api.reducerPath].subscriptions
+
+  // Should have subscriptions for getBanana(1), getBanana(2), and getBananas()
+  expect(subscriptionState).toMatchObject({
+    'getBanana(1)': {
+      [subscription1.requestId]: { pollingInterval: 1000 },
+    },
+    'getBanana(2)': {
+      [subscription2.requestId]: { refetchOnFocus: true },
+    },
+    'getBananas(undefined)': {
+      [subscription3.requestId]: {},
+    },
+  })
+
+  // Verify the subscription entries have the expected structure
+  expect(Object.keys(subscriptionState)).toHaveLength(3)
+  expect(subscriptionState['getBanana(1)']?.[subscription1.requestId]).toEqual({
+    pollingInterval: 1000,
+  })
+  expect(subscriptionState['getBanana(2)']?.[subscription2.requestId]).toEqual({
+    refetchOnFocus: true,
+  })
+  expect(
+    subscriptionState['getBananas(undefined)']?.[subscription3.requestId],
+  ).toEqual({})
 })
- 
-it.each([{ mutationArg: 'Bread' as "Bread" | null | undefined  }, { mutationArg: undefined }, { mutationArg: null }])('does not invalidate queries when a mutation with tags=[$mutationArg] runs and does not match anything', async ({ mutationArg }) => {
-  await storeRef.store.dispatch(getBanana.initiate(1))
-  await storeRef.store.dispatch(invalidateFruit.initiate(mutationArg))
-
-  // Slight pause to let the middleware run and such
-  await delay(20)
-
-  const apiActions = [
-    api.internalActions.middlewareRegistered.match,
-    getBanana.matchPending,
-    getBanana.matchFulfilled,
-    invalidateFruit.matchPending,
-    invalidateFruit.matchFulfilled,
-  ]
-
-  expect(storeRef.store.getState().actions).toMatchSequence(...apiActions)
-})