Introduce useEntityRecords unit tests

Author: widoz

sources/js/src/hooks/use-entity-records.ts

@@ -3,7 +3,16 @@ import { Set } from 'immutable';
 
 import { useEntityRecords as useCoreEntityRecords } from '@wordpress/core-data';
 
-// TODO `useEntityRecords` needs tests
+/**
+ * The hook will return an empty collection while resolving.
+ * This is to guarantee a better flow in the data manipulation, therefore do not count on the data returned by the
+ * `records()` as an indicator of the hook status.
+ *
+ * @internal
+ * @param kind The kind of entity to fetch. E.g. 'root', 'postType', 'taxonomy', etc.
+ * @param name The name of the entity to fetch. E.g. 'post', 'page', 'category', etc.
+ * @param queryArgs The query args to pass to the entity fetch. E.g. { per_page: 100 }
+ */
 export function useEntityRecords<Entity>(
 	kind: string,
 	name: string,

sources/js/src/hooks/use-query-viewable-post-types.ts

@@ -3,7 +3,6 @@ import { Set } from 'immutable';
 
 import { useEntityRecords } from './use-entity-records';
 
-// TODO `useQueryViewablePostTypes` require more unit tests
 export function useQueryViewablePostTypes(): EntitiesSearch.EntitiesRecords<EntitiesSearch.ViewablePostType> {
 	const entitiesRecords = useEntityRecords<EntitiesSearch.PostType<'edit'>>(
 		'root',

tests/js/unit/hooks/use-entity-records.test.ts

@@ -0,0 +1,118 @@
+import { fromPartial } from '@total-typescript/shoehorn';
+import EntitiesSearch from '@types';
+
+import { describe, it, jest, expect } from '@jest/globals';
+
+import { useEntityRecords as useCoreEntityRecords } from '@wordpress/core-data';
+
+import { useEntityRecords } from '../../../../sources/js/src';
+
+jest.mock('@wordpress/core-data', () => ({
+	useEntityRecords: jest.fn(),
+}));
+
+describe('useEntityRecords', () => {
+	/*
+	 * We want to guarantee the Records are returned and the hook succeeds.
+	 * Shouldn't be possible to obtain a succeed status if the records are resolving or errored.
+	 */
+	it('return set of records and succeed', () => {
+		const records = [
+			fromPartial<EntitiesSearch.PostType<'edit'>>({
+				name: 'foo',
+			}),
+			fromPartial<EntitiesSearch.PostType<'edit'>>({
+				name: 'foo-3',
+			}),
+		];
+
+		jest.mocked(useCoreEntityRecords).mockReturnValue({
+			records,
+			hasResolved: true,
+			isResolving: false,
+			// @ts-ignore
+			status: EntitiesSearch.ResolveStatus.SUCCESS,
+		});
+
+		const result = useEntityRecords<EntitiesSearch.PostType<'edit'>>(
+			'root',
+			'postType'
+		);
+
+		expect(result.records().size).toEqual(2);
+		for (const record of records) {
+			expect(result.records()).toContain(record);
+		}
+
+		expect(result.isResolving()).toEqual(false);
+		expect(result.errored()).toEqual(false);
+		expect(result.succeed()).toEqual(true);
+	});
+
+	/*
+	 * We want to guarantee `records()` returns null when the hook is resolving.
+	 */
+	it('return an empty collection of records when resolving', () => {
+		jest.mocked(useCoreEntityRecords).mockReturnValue({
+			records: null,
+			hasResolved: false,
+			isResolving: true,
+			// @ts-ignore
+			status: EntitiesSearch.ResolveStatus.RESOLVING,
+		});
+
+		const result = useEntityRecords<EntitiesSearch.PostType<'edit'>>(
+			'root',
+			'postType'
+		);
+
+		expect(result.records().isEmpty()).toEqual(true);
+		expect(result.isResolving()).toEqual(true);
+		expect(result.errored()).toEqual(false);
+		expect(result.succeed()).toEqual(false);
+	});
+
+	/*
+	 * We want to errored and succeed are not returning the same value.
+	 */
+	it('return errored and succeed as different values', () => {
+		jest.mocked(useCoreEntityRecords).mockReturnValue({
+			records: null,
+			hasResolved: true,
+			isResolving: false,
+			// @ts-ignore
+			status: EntitiesSearch.ResolveStatus.ERROR,
+		});
+
+		const result = useEntityRecords<EntitiesSearch.PostType<'edit'>>(
+			'root',
+			'postType'
+		);
+
+		expect(result.isResolving()).toEqual(false);
+		expect(result.errored()).toEqual(true);
+		expect(result.succeed()).toEqual(false);
+	});
+
+	/*
+	 * We want to guarantee the errored and success statuses are not returning `true` while resolving.
+	 */
+	it('return errored and succeed as false while resolving', () => {
+		jest.mocked(useCoreEntityRecords).mockReturnValue({
+			records: null,
+			hasResolved: false,
+			isResolving: true,
+			// @ts-ignore
+			status: EntitiesSearch.ResolveStatus.RESOLVING,
+		});
+
+		const result = useEntityRecords<EntitiesSearch.PostType<'edit'>>(
+			'root',
+			'postType'
+		);
+
+		expect(result.isResolving()).toEqual(true);
+		expect(result.errored()).toEqual(false);
+		expect(result.succeed()).toEqual(false);
+	});
+});