@wordpress/core-data 7.30.1-next.836ecdcae.0 → 7.31.0

package/src/test/selectors.js

@@ -8,7 +8,7 @@ import deepFreeze from 'deep-freeze';
  */
 import {
 	getEntityRecord,
-	__experimentalGetEntityRecordNoResolver,
+	hasEntityRecord,
 	hasEntityRecords,
 	getEntityRecords,
 	getRawEntityRecord,
@@ -25,11 +25,7 @@ import {
 	getRevision,
 } from '../selectors';
 
-// getEntityRecord and __experimentalGetEntityRecordNoResolver selectors share the same tests.
-describe.each( [
-	[ getEntityRecord ],
-	[ __experimentalGetEntityRecordNoResolver ],
-] )( '%p', ( selector ) => {
+describe( 'getEntityRecord', () => {
 	describe( 'normalizing Post ID passed as recordKey', () => {
 		it( 'normalizes any Post ID recordKey argument to a Number via `__unstableNormalizeArgs` method', async () => {
 			const normalized = getEntityRecord.__unstableNormalizeArgs( [
@@ -70,7 +66,7 @@ describe.each( [
 				},
 			},
 		} );
-		expect( selector( state, 'foo', 'bar', 'baz' ) ).toBeUndefined();
+		expect( getEntityRecord( state, 'foo', 'bar', 'baz' ) ).toBeUndefined();
 	} );
 
 	it( 'should return undefined for unknown record’s key', () => {
@@ -89,7 +85,9 @@ describe.each( [
 				},
 			},
 		} );
-		expect( selector( state, 'root', 'postType', 'post' ) ).toBeUndefined();
+		expect(
+			getEntityRecord( state, 'root', 'postType', 'post' )
+		).toBeUndefined();
 	} );
 
 	it( 'should return a record by key', () => {
@@ -116,16 +114,98 @@ describe.each( [
 				},
 			},
 		} );
-		expect( selector( state, 'root', 'postType', 'post' ) ).toEqual( {
-			slug: 'post',
+		expect( getEntityRecord( state, 'root', 'postType', 'post' ) ).toEqual(
+			{
+				slug: 'post',
+			}
+		);
+	} );
+
+	it( 'should return undefined if no item received, filtered item requested', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					root: {
+						postType: {
+							queriedData: {
+								items: {},
+								itemIsComplete: {},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
 		} );
+
+		expect(
+			getEntityRecord( state, 'root', 'postType', 'post', {
+				_fields: 'content',
+			} )
+		).toBeUndefined();
 	} );
 
-	it( 'should return null if no item received, filtered item requested', () => {} );
+	it( 'should return filtered item if incomplete item received, filtered item requested', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					root: {
+						postType: {
+							queriedData: {
+								items: {
+									default: {
+										post: {
+											content: 'chicken',
+											author: 'bob',
+										},
+									},
+								},
+								itemIsComplete: {},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
+		} );
 
-	it( 'should return filtered item if incomplete item received, filtered item requested', () => {} );
+		expect(
+			getEntityRecord( state, 'root', 'postType', 'post', {
+				_fields: 'content',
+			} )
+		).toEqual( { content: 'chicken' } );
+	} );
+
+	it( 'should return undefined if incomplete item received, complete item requested', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					root: {
+						postType: {
+							queriedData: {
+								items: {
+									default: {
+										post: {
+											content: 'chicken',
+											author: 'bob',
+										},
+									},
+								},
+								itemIsComplete: {},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
+		} );
 
-	it( 'should return null if incomplete item received, complete item requested', () => {} );
+		expect(
+			getEntityRecord( state, 'root', 'postType', 'post', {
+				context: 'default',
+			} )
+		).toBeUndefined();
+	} );
 
 	it( 'should return filtered item if complete item received, filtered item requested', () => {
 		const state = deepFreeze( {
@@ -200,6 +280,133 @@ describe.each( [
 	} );
 } );
 
+describe( 'hasEntityRecord', () => {
+	it( 'returns false if entity record has not been received', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							queriedData: {
+								items: {},
+								itemIsComplete: {},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect( hasEntityRecord( state, 'postType', 'post', 1 ) ).toBe( false );
+	} );
+
+	it( 'returns true when full record exists and no fields query', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							queriedData: {
+								items: {
+									default: {
+										1: { id: 1, content: 'hello' },
+									},
+								},
+								itemIsComplete: {
+									default: {
+										1: true,
+									},
+								},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect( hasEntityRecord( state, 'postType', 'post', 1 ) ).toBe( true );
+	} );
+
+	it( 'returns true when requested fields exist on the item', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							queriedData: {
+								items: {
+									default: {
+										1: {
+											id: 1,
+											content: 'chicken',
+											title: { raw: 'egg' },
+											author: 'bob',
+										},
+									},
+								},
+								itemIsComplete: {
+									default: {
+										1: true,
+									},
+								},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect(
+			hasEntityRecord( state, 'postType', 'post', 1, {
+				_fields: [ 'id', 'content' ],
+			} )
+		).toBe( true );
+		// Test nested field.
+		expect(
+			hasEntityRecord( state, 'postType', 'post', 1, {
+				_fields: [ 'id', 'title.raw' ],
+			} )
+		).toBe( true );
+	} );
+
+	it( 'returns false when a requested fields are missing', () => {
+		const state = deepFreeze( {
+			entities: {
+				records: {
+					postType: {
+						post: {
+							queriedData: {
+								items: {
+									default: {
+										1: { id: 1, author: 'bob' },
+									},
+								},
+								itemIsComplete: {
+									default: {
+										1: true,
+									},
+								},
+								queries: {},
+							},
+						},
+					},
+				},
+			},
+		} );
+		expect(
+			hasEntityRecord( state, 'postType', 'post', 1, {
+				_fields: [ 'id', 'content' ],
+			} )
+		).toBe( false );
+		// Test nested field.
+		expect(
+			hasEntityRecord( state, 'postType', 'post', 1, {
+				_fields: [ 'id', 'title.raw' ],
+			} )
+		).toBe( false );
+	} );
+} );
+
 describe( 'hasEntityRecords', () => {
 	it( 'returns false if entity records have not been received', () => {
 		const state = deepFreeze( {

package/src/test/store.js

@@ -0,0 +1,114 @@
+/**
+ * WordPress dependencies
+ */
+import triggerFetch from '@wordpress/api-fetch';
+import { createRegistry } from '@wordpress/data';
+
+/**
+ * Internal dependencies
+ */
+import { store as coreDataStore } from '../index';
+
+jest.mock( '@wordpress/api-fetch' );
+
+function createTestRegistry() {
+	const registry = createRegistry();
+
+	// Register the core-data store
+	registry.register( coreDataStore );
+
+	const postEntityConfig = {
+		kind: 'postType',
+		baseURL: '/wp/v2/posts',
+		baseURLParams: {
+			context: 'edit',
+		},
+		name: 'post',
+		label: 'Posts',
+		transientEdits: {
+			blocks: true,
+			selection: true,
+		},
+		mergedEdits: {
+			meta: true,
+		},
+		rawAttributes: [ 'title', 'excerpt', 'content' ],
+		__unstable_rest_base: 'posts',
+		supportsPagination: true,
+		revisionKey: 'id',
+	};
+
+	// Add the post entity to the store
+	registry.dispatch( coreDataStore ).addEntities( [ postEntityConfig ] );
+
+	return registry;
+}
+
+function createTestPost( id = 1, fields = [] ) {
+	const post = {
+		id,
+		author: 1,
+		content: {
+			raw: '<!-- wp:paragraph -->\n<p>A paragraph</p>\n<!-- /wp:paragraph -->',
+			rendered: '\n<p>A paragraph</p>\n',
+		},
+		excerpt: {
+			raw: '',
+			rendered: '<p>A paragraph</p>\n',
+		},
+		title: {
+			raw: 'Test',
+			rendered: 'Test',
+		},
+		featured_media: 0,
+		type: 'post',
+		status: 'draft',
+		slug: '',
+	};
+
+	if ( fields.length > 0 ) {
+		return Object.fromEntries(
+			fields.map( ( field ) => [ field, post[ field ] ] )
+		);
+	}
+
+	return post;
+}
+
+describe( 'getEntityRecord', () => {
+	let registry;
+
+	beforeEach( () => {
+		registry = createTestRegistry();
+		triggerFetch.mockReset();
+	} );
+
+	it( 'should not make a request if the record is already in store', async () => {
+		const { getEntityRecord } = registry.resolveSelect( coreDataStore );
+		const post = createTestPost( 1 );
+		triggerFetch.mockResolvedValue( {
+			async json() {
+				return post;
+			},
+		} );
+
+		// Resolve the record.
+		await expect(
+			getEntityRecord( 'postType', 'post', post.id, { context: 'edit' } )
+		).resolves.toEqual( post );
+
+		triggerFetch.mockReset();
+
+		await expect(
+			getEntityRecord( 'postType', 'post', post.id, {
+				context: 'edit',
+				_fields: [ 'id', 'author', 'title' ],
+			} )
+		).resolves.toEqual( {
+			id: post.id,
+			author: post.author,
+			title: post.title,
+		} );
+		expect( triggerFetch ).not.toHaveBeenCalled();
+	} );
+} );