@automattic/data-stores 3.2.0 → 3.2.1

package/src/reader/mutations/use-site-email-me-new-posts-mutation.ts

@@ -1,11 +1,15 @@
+import {
+	getSiteSubscriptionsQueryKey,
+	type SiteSubscriptionsInfiniteData,
+} from '@automattic/api-queries';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { buildQueryKey, callApi } from '../helpers';
+import { callApi } from '../helpers';
 import {
 	alterSiteSubscriptionDetails,
 	invalidateSiteSubscriptionDetails,
 } from '../helpers/optimistic-update';
 import { useIsLoggedIn } from '../hooks';
-import type { SiteSubscriptionsPages, SiteSubscriptionDetails } from '../types';
+import type { SiteSubscriptionDetails } from '../types';
 
 type SiteSubscriptionEmailMeNewPostsParams = {
 	send_posts: boolean;
@@ -50,16 +54,12 @@ const useSiteEmailMeNewPostsMutation = () => {
 			return response;
 		},
 		onMutate: async ( { blog_id, send_posts, subscriptionId } ) => {
-			const siteSubscriptionsQueryKey = buildQueryKey(
-				[ 'read', 'site-subscriptions' ],
-				isLoggedIn,
-				id
-			);
+			const siteSubscriptionsQueryKey = getSiteSubscriptionsQueryKey();
 
 			await queryClient.cancelQueries( { queryKey: siteSubscriptionsQueryKey } );
 
 			const previousSiteSubscriptions =
-				queryClient.getQueryData< SiteSubscriptionsPages >( siteSubscriptionsQueryKey );
+				queryClient.getQueryData< SiteSubscriptionsInfiniteData >( siteSubscriptionsQueryKey );
 			if ( previousSiteSubscriptions ) {
 				queryClient.setQueryData( siteSubscriptionsQueryKey, {
 					...previousSiteSubscriptions,
@@ -67,7 +67,7 @@ const useSiteEmailMeNewPostsMutation = () => {
 						return {
 							...page,
 							subscriptions: page.subscriptions.map( ( siteSubscription ) => {
-								if ( siteSubscription.blog_ID === blog_id ) {
+								if ( Number( siteSubscription.blog_ID ) === Number( blog_id ) ) {
 									return {
 										...siteSubscription,
 										delivery_methods: {
@@ -116,7 +116,7 @@ const useSiteEmailMeNewPostsMutation = () => {
 		onError: ( _err, _, context ) => {
 			if ( context?.previousSiteSubscriptions ) {
 				queryClient.setQueryData(
-					buildQueryKey( [ 'read', 'site-subscriptions' ], isLoggedIn, id ),
+					getSiteSubscriptionsQueryKey(),
 					context.previousSiteSubscriptions
 				);
 			}

package/src/reader/mutations/use-site-notify-me-of-new-posts-mutation.ts

@@ -1,11 +1,15 @@
+import {
+	getSiteSubscriptionsQueryKey,
+	type SiteSubscriptionsInfiniteData,
+} from '@automattic/api-queries';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { buildQueryKey, callApi } from '../helpers';
+import { callApi } from '../helpers';
 import {
 	alterSiteSubscriptionDetails,
 	invalidateSiteSubscriptionDetails,
 } from '../helpers/optimistic-update';
 import { useIsLoggedIn } from '../hooks';
-import type { SiteSubscriptionsPages, SiteSubscriptionDetails } from '../types';
+import type { SiteSubscriptionDetails } from '../types';
 
 type SiteSubscriptionNotifyMeOfNewPostsParams = {
 	send_posts: boolean;
@@ -51,16 +55,12 @@ const useSiteNotifyMeOfNewPostsMutation = () => {
 			return response;
 		},
 		onMutate: async ( { blog_id, send_posts, subscriptionId } ) => {
-			const siteSubscriptionsQueryKey = buildQueryKey(
-				[ 'read', 'site-subscriptions' ],
-				isLoggedIn,
-				id
-			);
+			const siteSubscriptionsQueryKey = getSiteSubscriptionsQueryKey();
 
 			await queryClient.cancelQueries( { queryKey: siteSubscriptionsQueryKey } );
 
 			const previousSiteSubscriptions =
-				queryClient.getQueryData< SiteSubscriptionsPages >( siteSubscriptionsQueryKey );
+				queryClient.getQueryData< SiteSubscriptionsInfiniteData >( siteSubscriptionsQueryKey );
 
 			if ( previousSiteSubscriptions ) {
 				queryClient.setQueryData( siteSubscriptionsQueryKey, {
@@ -69,7 +69,7 @@ const useSiteNotifyMeOfNewPostsMutation = () => {
 						return {
 							...page,
 							subscriptions: page.subscriptions.map( ( siteSubscription ) => {
-								if ( siteSubscription.blog_ID === blog_id ) {
+								if ( Number( siteSubscription.blog_ID ) === Number( blog_id ) ) {
 									return {
 										...siteSubscription,
 										delivery_methods: {
@@ -118,7 +118,7 @@ const useSiteNotifyMeOfNewPostsMutation = () => {
 		onError: ( err, _, context ) => {
 			if ( context?.previousSiteSubscriptions ) {
 				queryClient.setQueryData(
-					buildQueryKey( [ 'read', 'site-subscriptions' ], isLoggedIn, id ),
+					getSiteSubscriptionsQueryKey(),
 					context.previousSiteSubscriptions
 				);
 			}

package/src/reader/mutations/use-site-subscribe-mutation.ts

@@ -1,7 +1,10 @@
+import {
+	getSiteSubscriptionsQueryKey,
+	type SiteSubscriptionsInfiniteData,
+} from '@automattic/api-queries';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { buildQueryKey, callApi, getSubscriptionMutationParams, isValidId } from '../helpers';
 import { useIsLoggedIn } from '../hooks';
-import { SiteSubscriptionsPages } from '../types';
 import type { SiteSubscriptionDetails } from '../types';
 
 type SubscribeParams = {
@@ -20,6 +23,7 @@ type SubscribeResponse = {
 	success?: boolean;
 	subscribed?: boolean;
 	subscription?: {
+		ID: string;
 		blog_ID: string;
 		delivery_frequency: string;
 		status: string;
@@ -38,11 +42,7 @@ const buildSubscriptionDetailsByBlogIdQueryKey = (
 const useSiteSubscribeMutation = () => {
 	const { isLoggedIn, id: userId } = useIsLoggedIn();
 	const queryClient = useQueryClient();
-	const siteSubscriptionsCacheKey = buildQueryKey(
-		[ 'read', 'site-subscriptions' ],
-		isLoggedIn,
-		userId
-	);
+	const siteSubscriptionsCacheKey = getSiteSubscriptionsQueryKey();
 	const subscriptionsCountCacheKey = buildQueryKey(
 		[ 'read', 'subscriptions-count' ],
 		isLoggedIn,
@@ -68,7 +68,8 @@ const useSiteSubscribeMutation = () => {
 			if ( ! response.subscribed ) {
 				throw new Error(
 					// reminder: translate this string when we add it to the UI
-					'Something went wrong while subscribing.'
+					'Something went wrong while subscribing.',
+					{ cause: response.info }
 				);
 			}
 
@@ -98,20 +99,30 @@ const useSiteSubscribeMutation = () => {
 			}
 
 			const previousSiteSubscriptions =
-				queryClient.getQueryData< SiteSubscriptionsPages >( siteSubscriptionsCacheKey );
+				queryClient.getQueryData< SiteSubscriptionsInfiniteData >( siteSubscriptionsCacheKey );
 
 			if ( previousSiteSubscriptions ) {
 				queryClient.setQueryData( siteSubscriptionsCacheKey, {
 					...previousSiteSubscriptions,
 					pages: previousSiteSubscriptions.pages.map( ( page ) => {
+						const shouldIncreaseTotalCount = page.subscriptions.some(
+							( siteSubscription ) =>
+								Number( siteSubscription.blog_ID ) === Number( params.blog_id ) &&
+								( siteSubscription.isDeleted || ! siteSubscription.is_following )
+						);
+
 						return {
 							...page,
-							total_subscriptions: page.total_subscriptions - 1,
+							totalCount:
+								typeof page.totalCount === 'number' && shouldIncreaseTotalCount
+									? page.totalCount + 1
+									: page.totalCount,
 							subscriptions: page.subscriptions.map( ( siteSubscription ) =>
-								siteSubscription.blog_ID === params.blog_id
+								Number( siteSubscription.blog_ID ) === Number( params.blog_id )
 									? {
 											...siteSubscription,
 											date_subscribed: new Date(),
+											is_following: true,
 											isDeleted: false,
 											resubscribed: params.resubscribed ?? false,
 									  }

package/src/reader/mutations/use-site-unsubscribe-mutation.ts

@@ -1,11 +1,12 @@
+import {
+	getSiteSubscriptionsQueryKey,
+	type SiteSubscriptionsInfiniteData,
+} from '@automattic/api-queries';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { buildQueryKey, callApi, getSubscriptionMutationParams, isValidId } from '../helpers';
 import { useCacheKey, useIsLoggedIn } from '../hooks';
-import {
-	SiteSubscriptionsPages,
-	SubscriptionManagerSubscriptionsCount,
-	SiteSubscriptionDetails,
-} from '../types';
+import { SubscriptionManagerSubscriptionsCount, SiteSubscriptionDetails } from '../types';
+import type { SiteSubscriptionItem } from '@automattic/api-core';
 
 type UnsubscribeParams = {
 	subscriptionId: number;
@@ -46,7 +47,7 @@ const buildSiteSubscriptionDetailsQueryKey = (
 const useSiteUnsubscribeMutation = () => {
 	const { isLoggedIn, id: userId } = useIsLoggedIn();
 	const queryClient = useQueryClient();
-	const siteSubscriptionsQueryKey = useCacheKey( [ 'read', 'site-subscriptions' ] );
+	const siteSubscriptionsQueryKey = getSiteSubscriptionsQueryKey();
 	const subscriptionsCountQueryKey = useCacheKey( [ 'read', 'subscriptions-count' ] );
 
 	return useMutation( {
@@ -93,21 +94,30 @@ const useSiteUnsubscribeMutation = () => {
 			await queryClient.cancelQueries( { queryKey: siteSubscriptionDetailsQueryKey } );
 
 			const previousSiteSubscriptions =
-				queryClient.getQueryData< SiteSubscriptionsPages >( siteSubscriptionsQueryKey );
+				queryClient.getQueryData< SiteSubscriptionsInfiniteData >( siteSubscriptionsQueryKey );
 
 			// remove blog from site subscriptions
 			if ( previousSiteSubscriptions ) {
 				queryClient.setQueryData( siteSubscriptionsQueryKey, {
 					...previousSiteSubscriptions,
 					pages: previousSiteSubscriptions.pages.map( ( page ) => {
+						const isTargetSubscription = ( siteSubscription: SiteSubscriptionItem ) =>
+							Number( siteSubscription.ID ) === params.subscriptionId ||
+							( isValidId( params.blog_id ) &&
+								Number( siteSubscription.blog_ID ) === Number( params.blog_id ) );
+						const shouldDecrementTotalCount = page.subscriptions.some( isTargetSubscription );
+
 						return {
 							...page,
-							total_subscriptions: page.total_subscriptions - 1,
+							totalCount:
+								typeof page.totalCount === 'number' && shouldDecrementTotalCount
+									? page.totalCount - 1
+									: page.totalCount,
 							subscriptions: page.subscriptions.map( ( siteSubscription ) =>
-								Number( siteSubscription.ID ) === params.subscriptionId ||
-								( isValidId( params.blog_id ) && siteSubscription.blog_ID === params.blog_id ) //siteSubscription.blog_ID is not valid ID for non-wpcom subscriptions, so when unsubscribing from such site, the param.blog_id will also be not valid, this would create false positive
+								isTargetSubscription( siteSubscription )
 									? {
 											...siteSubscription,
+											is_following: false,
 											isDeleted: true,
 											resubscribed: false,
 									  }

package/src/reader/queries/index.ts

@@ -1,15 +1,13 @@
 export { default as usePendingPostSubscriptionsQuery } from './use-pending-post-subscriptions-query';
 export { default as usePendingSiteSubscriptionsQuery } from './use-pending-site-subscriptions-query';
 export { default as usePostSubscriptionsQuery } from './use-post-subscriptions-query';
-export { default as useReadFeedSearchQuery, FeedSort } from './use-read-feed-search-query';
-export { default as useReadFeedSiteQuery } from './use-read-feed-site-query';
-export { default as useReadFeedQuery } from './use-read-feed-query';
 export { default as useSiteSubscriptionDetailsQuery } from './use-site-subscription-details-query';
 export {
 	default as useSiteSubscriptionsQuery,
 	siteSubscriptionsQueryKeyPrefix,
 } from './use-site-subscriptions-query';
-export { default as useSubscriptionsCountQuery } from './use-subscriptions-count-query';
+export {
+	default as useSubscriptionsCountQuery,
+	subscriptionsCountQueryKeyPrefix,
+} from './use-subscriptions-count-query';
 export { default as useUserSettingsQuery } from './use-user-settings-query';
-
-export type { FeedItem } from './use-read-feed-search-query';

package/src/reader/queries/test/use-site-subscriptions-query.tsx

@@ -1,10 +1,13 @@
 /**
  * @jest-environment jsdom
  */
+import {
+	getSiteSubscriptionsQueryKey,
+	type SiteSubscriptionsInfiniteData,
+} from '@automattic/api-queries';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { renderHook, waitFor } from '@testing-library/react';
-import React from 'react';
-import { act } from 'react-dom/test-utils';
+import React, { act } from 'react';
 import { SiteSubscriptionsSortBy } from '../../constants';
 import {
 	SiteSubscriptionsQueryPropsProvider,
@@ -12,8 +15,10 @@ import {
 } from '../../contexts';
 import { callApi, getSubkey } from '../../helpers';
 import useSiteSubscriptionsQuery from '../../queries/use-site-subscriptions-query';
+import type { SiteSubscriptionItem } from '../../types';
 
 jest.mock( '../../helpers', () => ( {
+	...jest.requireActual( '../../helpers' ),
 	callApi: jest.fn(),
 	getSubkey: jest.fn(),
 } ) );
@@ -26,60 +31,140 @@ const wrapper = ( { children } ) => (
 	</QueryClientProvider>
 );
 
+const makeFollow = ( overrides: Partial< SiteSubscriptionItem > = {} ): SiteSubscriptionItem => ( {
+	ID: '1',
+	URL: 'https://site1.example.com',
+	feed_URL: 'https://site1.example.com/feed',
+	blog_ID: '1',
+	feed_ID: '11',
+	is_following: true,
+	name: 'Site 1',
+	date_subscribed: new Date( '2024-01-01T00:00:00Z' ),
+	last_updated: new Date( '2024-01-01T00:00:00Z' ),
+	...overrides,
+} );
+
+const makeApiSubscription = ( id: number ) => ( {
+	ID: String( id ),
+	URL: `https://site${ id }.example.com/feed`,
+	blog_ID: String( id ),
+	feed_ID: String( id + 1000 ),
+	name: `Site ${ id }`,
+} );
+
+const makeSiteSubscriptionsData = (
+	pages: SiteSubscriptionItem[][],
+	totalCount = pages.reduce( ( count, page ) => count + page.length, 0 )
+): SiteSubscriptionsInfiniteData => ( {
+	pages: pages.map( ( subscriptions, index ) => ( {
+		subscriptions,
+		totalCount,
+		page: index + 1,
+		number: 200,
+	} ) ),
+	pageParams: pages.map( ( _, index ) => index + 1 ),
+} );
+
+const seedSiteSubscriptions = ( pages: SiteSubscriptionItem[][], totalCount?: number ) => {
+	queryClient.setQueryData< SiteSubscriptionsInfiniteData >(
+		getSiteSubscriptionsQueryKey(),
+		makeSiteSubscriptionsData( pages, totalCount )
+	);
+};
+
 describe( 'useSiteSubscriptionsQuery hook', () => {
 	beforeEach( () => {
 		queryClient.clear();
 		jest.resetAllMocks();
 
 		( getSubkey as jest.Mock ).mockReturnValue( () => 'test-key' );
+		( callApi as jest.Mock ).mockResolvedValue( {
+			subscriptions: [],
+			total_subscriptions: 0,
+			page: 1,
+			number: 200,
+		} );
 	} );
 
-	it( 'fetches subscriptions data with multiple pages', async () => {
-		( callApi as jest.Mock ).mockResolvedValueOnce( {
-			subscriptions: [
-				{ id: '1', name: 'Site 1', URL: 'https://site1.example.com' },
-				{ id: '2', name: 'Site 2', URL: 'https://site2.example.com' },
+	it( 'derives subscriptions data from multiple cached pages', async () => {
+		seedSiteSubscriptions( [
+			[
+				makeFollow( { ID: '1', name: 'Site 1', URL: 'https://site1.example.com' } ),
+				makeFollow( { ID: '2', name: 'Site 2', URL: 'https://site2.example.com' } ),
 			],
-			page: 1,
-			total_subscriptions: 6,
-		} );
-		( callApi as jest.Mock ).mockResolvedValueOnce( {
-			subscriptions: [
-				{ id: '3', name: 'Site 3', URL: 'https://site3.example.com' },
-				{ id: '4', name: 'Site 4', URL: 'https://site4.example.com' },
+			[
+				makeFollow( { ID: '3', name: 'Site 3', URL: 'https://site3.example.com' } ),
+				makeFollow( { ID: '4', name: 'Site 4', URL: 'https://site4.example.com' } ),
 			],
-			page: 2,
-			total_subscriptions: 6,
-		} );
-		( callApi as jest.Mock ).mockResolvedValueOnce( {
-			subscriptions: [
-				{ id: '5', name: 'Site 5', URL: 'https://site5.example.com' },
-				{ id: '6', name: 'Site 6', URL: 'https://site6.example.com' },
+			[
+				makeFollow( { ID: '5', name: 'Site 5', URL: 'https://site5.example.com' } ),
+				makeFollow( { ID: '6', name: 'Site 6', URL: 'https://site6.example.com' } ),
 			],
-			page: 3,
-			total_subscriptions: 6,
-		} );
+		] );
 
-		const { result } = renderHook( () => useSiteSubscriptionsQuery( { number: 2 } ), {
+		const { result } = renderHook( () => useSiteSubscriptionsQuery(), {
 			wrapper,
 		} );
 
 		await waitFor( () => {
-			expect( callApi ).toHaveBeenCalledTimes( 3 );
 			expect( result.current.data.subscriptions.length ).toBe( 6 );
 			expect( result.current.data.totalCount ).toBe( 6 );
 		} );
 	} );
 
+	it( 'fetches additional pages through the subkey-aware API path', async () => {
+		// The server caps each page at 100 rows, so a full page is 100 items.
+		const firstPage = Array.from( { length: 100 }, ( _value, index ) =>
+			makeApiSubscription( index + 1 )
+		);
+		const secondPage = [ makeApiSubscription( 101 ) ];
+
+		( callApi as jest.Mock ).mockImplementation( ( { path, isLoggedIn } ) => {
+			expect( isLoggedIn ).toBe( false );
+
+			if ( path.includes( 'page=1' ) ) {
+				return Promise.resolve( {
+					subscriptions: firstPage,
+					total_subscriptions: 101,
+					page: 1,
+					number: 100,
+				} );
+			}
+
+			if ( path.includes( 'page=2' ) ) {
+				return Promise.resolve( {
+					subscriptions: secondPage,
+					total_subscriptions: 101,
+					page: 2,
+					number: 1,
+				} );
+			}
+
+			throw new Error( `Unexpected path ${ path }` );
+		} );
+
+		const { result } = renderHook( () => useSiteSubscriptionsQuery(), {
+			wrapper,
+		} );
+
+		await waitFor( () => expect( callApi ).toHaveBeenCalledTimes( 2 ) );
+		await waitFor( () => expect( result.current.data.subscriptions ).toHaveLength( 101 ) );
+		expect( ( callApi as jest.Mock ).mock.calls[ 0 ][ 0 ] ).toMatchObject( {
+			apiVersion: '1.2',
+			isLoggedIn: false,
+		} );
+		expect( ( callApi as jest.Mock ).mock.calls[ 0 ][ 0 ].path ).toContain(
+			'/read/following/mine'
+		);
+	} );
+
 	it( 'fetches subscriptions data with search term', async () => {
-		( callApi as jest.Mock ).mockResolvedValue( {
-			subscriptions: [
-				{ id: '1', name: 'Site 1', URL: 'https://site1.example.com' },
-				{ id: '2', name: 'Site 2', URL: 'https://site2.example.com' },
+		seedSiteSubscriptions( [
+			[
+				makeFollow( { ID: '1', name: 'Site 1', URL: 'https://site1.example.com' } ),
+				makeFollow( { ID: '2', name: 'Site 2', URL: 'https://site2.example.com' } ),
 			],
-			page: 1,
-			total_subscriptions: 2,
-		} );
+		] );
 
 		const { result } = renderHook(
 			() => {
@@ -97,12 +182,36 @@ describe( 'useSiteSubscriptionsQuery hook', () => {
 		act( () => result.current.setSearchTerm( 'te 1' ) );
 		await waitFor( () => expect( result.current.searchTerm ).toBe( 'te 1' ) );
 
-		expect( callApi ).toHaveBeenCalledTimes( 1 );
 		expect( result.current.data.subscriptions.length ).toBe( 1 );
 		expect( result.current.data.subscriptions[ 0 ].name ).toBe( 'Site 1' );
 		expect( result.current.data.totalCount ).toBe( 2 );
 	} );
 
+	it( 'reuses fresh cached follows when remounted', async () => {
+		seedSiteSubscriptions( [
+			[ makeFollow( { ID: '1', name: 'Site 1', URL: 'https://site1.example.com' } ) ],
+		] );
+
+		const firstRender = renderHook( () => useSiteSubscriptionsQuery(), {
+			wrapper,
+		} );
+
+		await waitFor( () => expect( firstRender.result.current.isLoading ).toBe( false ) );
+		expect( firstRender.result.current.data.subscriptions ).toHaveLength( 1 );
+
+		firstRender.unmount();
+
+		const secondRender = renderHook( () => useSiteSubscriptionsQuery(), {
+			wrapper,
+		} );
+
+		await waitFor( () =>
+			expect( secondRender.result.current.data.subscriptions ).toHaveLength( 1 )
+		);
+
+		expect( secondRender.result.current.data.subscriptions ).toHaveLength( 1 );
+	} );
+
 	it.each( [
 		{
 			sortTerm: SiteSubscriptionsSortBy.SiteName,
@@ -129,33 +238,31 @@ describe( 'useSiteSubscriptionsQuery hook', () => {
 			],
 		},
 	] )( 'Applies sorting to the subscriptions returned', async ( { sortTerm, expectedResult } ) => {
-		( callApi as jest.Mock ).mockResolvedValue( {
-			subscriptions: [
-				{
+		seedSiteSubscriptions( [
+			[
+				makeFollow( {
 					ID: '1',
 					name: "Zorro's site",
 					URL: 'https://site2.example.com',
-					date_subscribed: '2022-01-18T00:00:00+00:00',
-					last_updated: '2023-04-18T19:00:00+00:00',
-				},
-				{
+					date_subscribed: new Date( '2022-01-18T00:00:00+00:00' ),
+					last_updated: new Date( '2023-04-18T19:00:00+00:00' ),
+				} ),
+				makeFollow( {
 					ID: '3',
 					name: "Maciej's site",
 					URL: 'https://site2.example.com',
-					date_subscribed: '2023-04-18T17:00:00+00:00',
-					last_updated: '2023-04-18T17:00:00+00:00',
-				},
-				{
+					date_subscribed: new Date( '2023-04-18T17:00:00+00:00' ),
+					last_updated: new Date( '2023-04-18T17:00:00+00:00' ),
+				} ),
+				makeFollow( {
 					ID: '2',
 					name: "Arnold's site",
 					URL: 'https://site1.example.com',
-					date_subscribed: '2023-04-18T12:00:00+00:00',
-					last_updated: '2023-04-18T12:00:00+00:00',
-				},
+					date_subscribed: new Date( '2023-04-18T12:00:00+00:00' ),
+					last_updated: new Date( '2023-04-18T12:00:00+00:00' ),
+				} ),
 			],
-			page: 1,
-			total_subscriptions: 3,
-		} );
+		] );
 
 		const { result } = renderHook(
 			() => {
@@ -172,7 +279,6 @@ describe( 'useSiteSubscriptionsQuery hook', () => {
 		act( () => result.current.setSortTerm( sortTerm ) );
 		await waitFor( () => expect( result.current.sortTerm ).toBe( sortTerm ) );
 
-		expect( callApi ).toHaveBeenCalledTimes( 1 );
 		result.current.data.subscriptions.forEach( ( subscription, index ) => {
 			expect( subscription.ID ).toEqual( expectedResult[ index ].ID );
 		} );