@wordpress/core-data 4.0.1 → 4.0.5

package/src/locks/test/engine.js

@@ -0,0 +1,135 @@
+/**
+ * Internal dependencies
+ */
+import createLocks from '../engine';
+
+jest.useRealTimers();
+
+// we correctly await all promises with expect calls, but the rule doesn't detect that
+/* eslint-disable jest/valid-expect-in-promise */
+
+describe( 'Locks engine', () => {
+	it( 'does not grant two exclusive locks at once', async () => {
+		const locks = createLocks();
+
+		let l1Granted = false;
+		let l2Granted = false;
+
+		// request two locks
+		const l1 = locks.acquire( 'store', [ 'root' ], true );
+		const l2 = locks.acquire( 'store', [ 'root' ], true );
+
+		// on each grant, verify that the other lock is not granted at the same time
+		const check1 = l1.then( () => {
+			l1Granted = true;
+			expect( l2Granted ).toBe( false );
+		} );
+
+		const check2 = l2.then( () => {
+			l2Granted = true;
+			expect( l1Granted ).toBe( false );
+		} );
+
+		// unlock both
+		const lock1 = await l1;
+		locks.release( lock1 );
+		l1Granted = false;
+
+		const lock2 = await l2;
+		locks.release( lock2 );
+		l2Granted = false;
+
+		// ensure that both locks were granted and checked
+		return await Promise.all( [ check1, check2 ] );
+	} );
+
+	it( 'does not grant an exclusive lock if a non-exclusive one already exists', async () => {
+		const locks = createLocks();
+
+		let l1Granted = false;
+		let l2Granted = false;
+
+		// request two locks
+		const l1 = locks.acquire( 'store', [ 'root' ], false );
+		const l2 = locks.acquire( 'store', [ 'root' ], true );
+
+		// on each grant, verify that the other lock is not granted at the same time
+		const check1 = l1.then( () => {
+			l1Granted = true;
+			expect( l2Granted ).toBe( false );
+		} );
+
+		const check2 = l2.then( () => {
+			l2Granted = true;
+			expect( l1Granted ).toBe( false );
+		} );
+
+		// unlock both
+		const lock1 = await l1;
+		locks.release( lock1 );
+		l1Granted = false;
+
+		const lock2 = await l2;
+		locks.release( lock2 );
+		l2Granted = false;
+
+		// ensure that both locks were granted and checked
+		return await Promise.all( [ check1, check2 ] );
+	} );
+
+	it( 'does not grant two exclusive locks to parent and child', async () => {
+		const locks = createLocks();
+
+		let l1Granted = false;
+		let l2Granted = false;
+
+		// request two locks
+		const l1 = locks.acquire( 'store', [ 'root' ], true );
+		const l2 = locks.acquire( 'store', [ 'root', 'child' ], true );
+
+		// on each grant, verify that the other lock is not granted at the same time
+		const check1 = l1.then( () => {
+			l1Granted = true;
+			expect( l2Granted ).toBe( false );
+		} );
+
+		const check2 = l2.then( () => {
+			l2Granted = true;
+			expect( l1Granted ).toBe( false );
+		} );
+
+		// unlock both
+		const lock1 = await l1;
+		locks.release( lock1 );
+		l1Granted = false;
+
+		const lock2 = await l2;
+		locks.release( lock2 );
+		l2Granted = false;
+
+		// ensure that both locks were granted and checked
+		return await Promise.all( [ check1, check2 ] );
+	} );
+
+	it( 'grants two non-exclusive locks at once', async () => {
+		const locks = createLocks();
+
+		const l1 = await locks.acquire( 'store', [ 'root' ], false );
+		const l2 = await locks.acquire( 'store', [ 'root' ], false );
+
+		expect( l1 ).not.toBeUndefined();
+		expect( l2 ).not.toBeUndefined();
+	} );
+
+	it( 'grants two exclusive locks to different branches', async () => {
+		const locks = createLocks();
+
+		const l1 = await locks.acquire( 'store', [ 'a' ], true );
+		const l2 = await locks.acquire( 'store', [ 'b' ], true );
+
+		expect( l1 ).not.toBeUndefined();
+		expect( l2 ).not.toBeUndefined();
+	} );
+} );
+
+/* eslint-enable jest/valid-expect-in-promise */

package/src/locks/test/reducer.js

@@ -6,7 +6,7 @@ import deepFreeze from 'deep-freeze';
 /**
  * Internal dependencies
  */
-import { locks } from '../reducer';
+import locks from '../reducer';
 
 const buildNode = ( children = {} ) => ( {
 	locks: [],

package/src/locks/test/selectors.js

@@ -6,58 +6,45 @@ import deepFreeze from 'deep-freeze';
 /**
  * Internal dependencies
  */
-import {
-	__unstableGetPendingLockRequests,
-	__unstableIsLockAvailable,
-} from '../selectors';
+import { getPendingLockRequests, isLockAvailable } from '../selectors';
 import { deepCopyLocksTreePath, getNode } from '../utils';
 
-describe( '__unstableGetPendingLockRequests', () => {
+describe( 'getPendingLockRequests', () => {
 	it( 'returns pending lock requests', () => {
 		const state = deepFreeze( {
-			locks: {
-				requests: [ 1, 2, 3 ],
-			},
+			requests: [ 1, 2, 3 ],
 		} );
 
-		expect( __unstableGetPendingLockRequests( state ) ).toEqual( [
-			1,
-			2,
-			3,
-		] );
+		expect( getPendingLockRequests( state ) ).toEqual( [ 1, 2, 3 ] );
 	} );
 } );
 
-describe( '__unstableIsLockAvailable', () => {
+describe( 'isLockAvailable', () => {
 	describe( 'smoke tests', () => {
 		it( 'returns true if lock is available', () => {
 			const state = deepFreeze( {
-				locks: {
-					tree: {
-						children: {},
-						locks: [],
-					},
+				tree: {
+					children: {},
+					locks: [],
 				},
 			} );
 
 			expect(
-				__unstableIsLockAvailable( state, 'core', [], {
+				isLockAvailable( state, 'core', [], {
 					exclusive: true,
 				} )
 			).toBe( true );
 		} );
 		it( 'returns false if lock is not available', () => {
 			const state = deepFreeze( {
-				locks: {
-					tree: {
-						children: {},
-						locks: [ { exclusive: false } ],
-					},
+				tree: {
+					children: {},
+					locks: [ { exclusive: false } ],
 				},
 			} );
 
 			expect(
-				__unstableIsLockAvailable( state, 'core', [], {
+				isLockAvailable( state, 'core', [], {
 					exclusive: true,
 				} )
 			).toBe( false );
@@ -75,7 +62,7 @@ describe( '__unstableIsLockAvailable', () => {
 		} );
 		it( `returns true if no parent or descendant has any locks`, () => {
 			expect(
-				__unstableIsLockAvailable(
+				isLockAvailable(
 					deepFreeze( state ),
 					'core',
 					[ 'entities', 'root' ],
@@ -89,7 +76,7 @@ describe( '__unstableIsLockAvailable', () => {
 				exclusive: true,
 			} );
 			expect(
-				__unstableIsLockAvailable(
+				isLockAvailable(
 					deepFreeze( state ),
 					'core',
 					[ 'entities', 'root' ],
@@ -103,7 +90,7 @@ describe( '__unstableIsLockAvailable', () => {
 				exclusive: true,
 			} );
 			expect(
-				__unstableIsLockAvailable(
+				isLockAvailable(
 					deepFreeze( state ),
 					'core',
 					[ 'entities', 'root' ],
@@ -114,41 +101,39 @@ describe( '__unstableIsLockAvailable', () => {
 
 		it( `returns true if another branch holds a locks (3)`, () => {
 			const subState = {
-				locks: {
-					tree: {
-						locks: [],
-						children: {
-							postType: {
-								locks: [],
-								children: {
-									post: {
-										locks: [],
-										children: {
-											16: {
-												locks: [
-													{
-														store: 'core',
-														path: [
-															'entities',
-															'data',
-															'postType',
-															'post',
-															16,
-														],
-														exclusive: true,
-													},
-												],
-												children: {},
-											},
+				tree: {
+					locks: [],
+					children: {
+						postType: {
+							locks: [],
+							children: {
+								post: {
+									locks: [],
+									children: {
+										16: {
+											locks: [
+												{
+													store: 'core',
+													path: [
+														'entities',
+														'data',
+														'postType',
+														'post',
+														16,
+													],
+													exclusive: true,
+												},
+											],
+											children: {},
 										},
 									},
-									wp_template_part: {
-										locks: [],
-										children: {
-											17: {
-												locks: [],
-												children: {},
-											},
+								},
+								wp_template_part: {
+									locks: [],
+									children: {
+										17: {
+											locks: [],
+											children: {},
 										},
 									},
 								},
@@ -158,7 +143,7 @@ describe( '__unstableIsLockAvailable', () => {
 				},
 			};
 			expect(
-				__unstableIsLockAvailable(
+				isLockAvailable(
 					deepFreeze( subState ),
 					'core',
 					[ 'postType', 'wp_template_part', 17 ],
@@ -169,41 +154,39 @@ describe( '__unstableIsLockAvailable', () => {
 
 		it( `returns true if another branch holds a locks (4)`, () => {
 			const subState = {
-				locks: {
-					tree: {
-						locks: [],
-						children: {
-							core: {
-								locks: [],
-								children: {
-									entities: {
-										locks: [],
-										children: {
-											data: {
-												locks: [],
-												children: {
-													postType: {
-														locks: [],
-														children: {
-															book: {
-																locks: [],
-																children: {
-																	67: {
-																		locks: [
-																			{
-																				path: [
-																					'core',
-																					'entities',
-																					'data',
-																					'postType',
-																					'book',
-																					67,
-																				],
-																				exclusive: true,
-																			},
-																		],
-																		children: {},
-																	},
+				tree: {
+					locks: [],
+					children: {
+						core: {
+							locks: [],
+							children: {
+								entities: {
+									locks: [],
+									children: {
+										data: {
+											locks: [],
+											children: {
+												postType: {
+													locks: [],
+													children: {
+														book: {
+															locks: [],
+															children: {
+																67: {
+																	locks: [
+																		{
+																			path: [
+																				'core',
+																				'entities',
+																				'data',
+																				'postType',
+																				'book',
+																				67,
+																			],
+																			exclusive: true,
+																		},
+																	],
+																	children: {},
 																},
 															},
 														},
@@ -219,7 +202,7 @@ describe( '__unstableIsLockAvailable', () => {
 				},
 			};
 			expect(
-				__unstableIsLockAvailable(
+				isLockAvailable(
 					deepFreeze( subState ),
 					'core',
 					[ 'entities', 'data', 'postType', 'book', 67 ],
@@ -231,7 +214,7 @@ describe( '__unstableIsLockAvailable', () => {
 		[ true, false ].forEach( ( exclusive ) => {
 			it( `returns true if the path is not accessible and no parent holds a lock`, () => {
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'fake', 'path' ],
@@ -245,7 +228,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'fake', 'path' ],
@@ -259,7 +242,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -273,7 +256,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -287,7 +270,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -306,7 +289,7 @@ describe( '__unstableIsLockAvailable', () => {
 					}
 				);
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -325,7 +308,7 @@ describe( '__unstableIsLockAvailable', () => {
 					}
 				);
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -345,7 +328,7 @@ describe( '__unstableIsLockAvailable', () => {
 		} );
 		it( `returns true if no parent or descendant has any locks`, () => {
 			expect(
-				__unstableIsLockAvailable(
+				isLockAvailable(
 					deepFreeze( state ),
 					'core',
 					[ 'entities', 'root' ],
@@ -361,7 +344,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive: isOtherLockExclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'fake', 'path' ],
@@ -375,7 +358,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive: isOtherLockExclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -389,7 +372,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive: isOtherLockExclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -403,7 +386,7 @@ describe( '__unstableIsLockAvailable', () => {
 					exclusive: isOtherLockExclusive,
 				} );
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -422,7 +405,7 @@ describe( '__unstableIsLockAvailable', () => {
 					}
 				);
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -441,7 +424,7 @@ describe( '__unstableIsLockAvailable', () => {
 					}
 				);
 				expect(
-					__unstableIsLockAvailable(
+					isLockAvailable(
 						deepFreeze( state ),
 						'core',
 						[ 'entities', 'root' ],
@@ -454,20 +437,18 @@ describe( '__unstableIsLockAvailable', () => {
 } );
 
 function appendLock( state, store, path, lock ) {
-	getNode( state.locks.tree, [ store, ...path ] ).locks.push( lock );
+	getNode( state.tree, [ store, ...path ] ).locks.push( lock );
 }
 
 function buildState( paths ) {
 	return {
-		locks: {
-			requests: [],
-			tree: paths.reduce(
-				( tree, path ) => deepCopyLocksTreePath( tree, path ),
-				{
-					locks: [],
-					children: {},
-				}
-			),
-		},
+		requests: [],
+		tree: paths.reduce(
+			( tree, path ) => deepCopyLocksTreePath( tree, path ),
+			{
+				locks: [],
+				children: {},
+			}
+		),
 	};
 }

package/src/queried-data/get-query-parts.js

@@ -20,6 +20,8 @@ import { withWeakMapCache, getNormalizedCommaSeparable } from '../utils';
  * @property {?(string[])} fields    Target subset of fields to derive from
  *                                   item objects.
  * @property {?(number[])} include   Specific item IDs to include.
+ * @property {string}      context   Scope under which the request is made;
+ *                                   determines returned fields in response.
  */
 
 /**
@@ -60,12 +62,6 @@ export function getQueryParts( query ) {
 				parts.perPage = Number( value );
 				break;
 
-			case 'include':
-				parts.include = getNormalizedCommaSeparable( value ).map(
-					Number
-				);
-				break;
-
 			case 'context':
 				parts.context = value;
 				break;
@@ -82,6 +78,15 @@ export function getQueryParts( query ) {
 					value = parts.fields.join();
 				}
 
+				// Two requests with different include values cannot have same results.
+				if ( key === 'include' ) {
+					parts.include = getNormalizedCommaSeparable( value ).map(
+						Number
+					);
+					// Normalize value for `stableKey`.
+					value = parts.include.join();
+				}
+
 				// While it could be any deterministic string, for simplicity's
 				// sake mimic querystring encoding for stable key.
 				//

package/src/queried-data/selectors.js

@@ -38,15 +38,7 @@ function getQueriedItemsUncached( state, query ) {
 	} = getQueryParts( query );
 	let itemIds;
 
-	if ( Array.isArray( include ) && ! stableKey ) {
-		// If the parsed query yields a set of IDs, but otherwise no filtering,
-		// it's safe to consider targeted item IDs as the include set. This
-		// doesn't guarantee that those objects have been queried, which is
-		// accounted for below in the loop `null` return.
-		itemIds = include;
-		// TODO: Avoid storing the empty stable string in reducer, since it
-		// can be computed dynamically here always.
-	} else if ( state.queries?.[ context ]?.[ stableKey ] ) {
+	if ( state.queries?.[ context ]?.[ stableKey ] ) {
 		itemIds = state.queries[ context ][ stableKey ];
 	}
 
@@ -67,6 +59,7 @@ function getQueriedItemsUncached( state, query ) {
 			continue;
 		}
 
+		// Having a target item ID doesn't guarantee that this object has been queried.
 		if ( ! state.items[ context ]?.hasOwnProperty( itemId ) ) {
 			return null;
 		}

package/src/queried-data/test/get-query-parts.js

@@ -24,7 +24,7 @@ describe( 'getQueryParts', () => {
 			context: 'default',
 			page: 1,
 			perPage: 10,
-			stableKey: '',
+			stableKey: 'include=1',
 			fields: null,
 			include: [ 1 ],
 		} );

package/src/queried-data/test/selectors.js

@@ -82,6 +82,7 @@ describe( 'getQueriedItems', () => {
 			queries: {
 				default: {
 					'': [ 1, 2 ],
+					'include=1': [ 1 ],
 				},
 			},
 		};