@wordpress/core-data 4.0.1 → 4.0.5

package/src/locks/test/actions.js

@@ -1,307 +0,0 @@
-/**
- * Internal dependencies
- */
-import {
-	__unstableAcquireStoreLock,
-	__unstableEnqueueLockRequest,
-	__unstableReleaseStoreLock,
-	__unstableProcessPendingLockRequests,
-} from '../actions';
-
-const store = 'test';
-const path = [ 'blue', 'bird' ];
-
-describe( '__unstableEnqueueLockRequest', () => {
-	it( 'Enqueues a lock request', async () => {
-		const fulfillment = __unstableEnqueueLockRequest( store, path, {
-			exclusive: true,
-		} );
-
-		// Start
-		expect( fulfillment.next().value ).toMatchObject( {
-			type: 'ENQUEUE_LOCK_REQUEST',
-			request: {
-				store,
-				path,
-				exclusive: true,
-				notifyAcquired: expect.any( Function ),
-			},
-		} );
-
-		// Should return a promise
-		expect( fulfillment.next() ).toMatchObject( {
-			done: true,
-			value: expect.any( Promise ),
-		} );
-	} );
-
-	it( 'Returns a promise fulfilled only after calling notifyAcquired', async () => {
-		const fulfillment = __unstableEnqueueLockRequest( store, path, {
-			exclusive: true,
-		} );
-		const { request } = fulfillment.next().value;
-		const promise = fulfillment.next().value;
-		const fulfilled = jest.fn();
-		promise.then( fulfilled );
-		// Fulfilled should not be called until notifyAcquired is called
-		await sleep( 1 );
-		expect( fulfilled ).not.toBeCalled();
-		const lock = {};
-		request.notifyAcquired( lock );
-		expect( fulfilled ).not.toBeCalled();
-
-		// Promises are resolved only the next tick, so let's wait a little:
-		await sleep( 1 );
-		expect( fulfilled ).toBeCalledTimes( 1 );
-
-		// Calling notifyAcquired again shouldn't have any effect:
-		request.notifyAcquired( lock );
-		await sleep( 1 );
-		expect( fulfilled ).toBeCalledTimes( 1 );
-	} );
-} );
-
-describe( '__unstableProcessPendingLockRequests', () => {
-	const exclusive = true;
-	const lock = { store, path, exclusive };
-
-	let notifyAcquired;
-	let request;
-
-	beforeEach( () => {
-		notifyAcquired = jest.fn();
-		request = { store, path, exclusive, notifyAcquired };
-	} );
-
-	it( 'Grants a lock request that may be granted', async () => {
-		const fulfillment = __unstableProcessPendingLockRequests();
-
-		// Start
-		expect( fulfillment.next().value.type ).toBe(
-			'PROCESS_PENDING_LOCK_REQUESTS'
-		);
-
-		// Get pending lock requests
-		expect( fulfillment.next().value.type ).toBe( '@@data/SELECT' );
-
-		// Find one and check if the request may be granted
-		expect( fulfillment.next( [ request ] ).value.type ).toBe(
-			'@@data/SELECT'
-		);
-
-		// It may, grant it
-		expect( fulfillment.next( true ).value.type ).toBe(
-			'GRANT_LOCK_REQUEST'
-		);
-
-		// Ensure the promise isn't fulfilled until after GRANT_LOCK_REQUEST finishes
-		expect( notifyAcquired ).not.toBeCalled();
-
-		// All requests processed, return
-		expect( fulfillment.next() ).toMatchObject( {
-			done: true,
-			value: undefined,
-		} );
-
-		// Ensure the promise is fulfilled once GRANT_LOCK_REQUEST finishes
-		expect( notifyAcquired ).toBeCalledWith( lock );
-		expect( notifyAcquired ).toBeCalledTimes( 1 );
-
-		// All requests processed, return
-		expect( fulfillment.next() ).toMatchObject( {
-			done: true,
-			value: undefined,
-		} );
-	} );
-
-	it( 'Does not grants a lock request that may not be granted', async () => {
-		const fulfillment = __unstableProcessPendingLockRequests();
-
-		// Start
-		expect( fulfillment.next().value.type ).toBe(
-			'PROCESS_PENDING_LOCK_REQUESTS'
-		);
-
-		// Get pending lock requests
-		expect( fulfillment.next().value.type ).toBe( '@@data/SELECT' );
-
-		// Find one and check if the request may be granted
-		expect( fulfillment.next( [ request ] ).value.type ).toBe(
-			'@@data/SELECT'
-		);
-
-		// It may not, let's finish
-		expect( fulfillment.next( false ) ).toMatchObject( {
-			done: true,
-			value: undefined,
-		} );
-	} );
-
-	it( 'Handles multiple lock requests', async () => {
-		const fulfillment = __unstableProcessPendingLockRequests();
-
-		// Start
-		expect( fulfillment.next().value.type ).toBe(
-			'PROCESS_PENDING_LOCK_REQUESTS'
-		);
-
-		// Get pending lock requests
-		expect( fulfillment.next().value.type ).toBe( '@@data/SELECT' );
-
-		// Find one and check if the request may be granted
-		expect( fulfillment.next( [ request, request ] ).value.type ).toBe(
-			'@@data/SELECT'
-		);
-
-		// It may not, continue - check if the next one may be granted
-		expect( fulfillment.next( false ).value.type ).toBe( '@@data/SELECT' );
-		// It may, grant it
-		expect( fulfillment.next( true ).value.type ).toBe(
-			'GRANT_LOCK_REQUEST'
-		);
-
-		// Ensure the promise isn't fulfilled until after GRANT_LOCK_REQUEST finishes
-		expect( notifyAcquired ).not.toBeCalled();
-
-		// All requests processed, return
-		expect( fulfillment.next() ).toMatchObject( {
-			done: true,
-			value: undefined,
-		} );
-
-		// Ensure the promise is fulfilled once GRANT_LOCK_REQUEST finishes
-		expect( notifyAcquired ).toBeCalledWith( lock );
-		expect( notifyAcquired ).toBeCalledTimes( 1 );
-
-		// All requests processed, return
-		expect( fulfillment.next() ).toMatchObject( {
-			done: true,
-			value: undefined,
-		} );
-	} );
-} );
-
-describe( '__unstableAcquireStoreLock', () => {
-	const exclusive = true;
-	const lock = { store, path, exclusive };
-
-	let notifyAcquired;
-	let request;
-
-	beforeEach( () => {
-		notifyAcquired = jest.fn();
-		request = { store, path, exclusive, notifyAcquired };
-	} );
-
-	it( 'Enqueues a lock request and attempts to fulfill it', async () => {
-		const fulfillment = __unstableAcquireStoreLock( store, path, {
-			exclusive,
-		} );
-
-		// Start
-		expect( fulfillment.next().value.type ).toBe( 'ENQUEUE_LOCK_REQUEST' );
-
-		// Get pending lock requests
-		expect( fulfillment.next().value.type ).toBe(
-			'PROCESS_PENDING_LOCK_REQUESTS'
-		);
-		expect( fulfillment.next().value.type ).toBe( '@@data/SELECT' );
-
-		// Check if lock may be granted
-		expect( fulfillment.next( [ request ] ).value.type ).toBe(
-			'@@data/SELECT'
-		);
-
-		// Grant lock request
-		expect( fulfillment.next( true ).value.type ).toBe(
-			'GRANT_LOCK_REQUEST'
-		);
-
-		// Ensure the promise isn't fulfilled until after GRANT_LOCK_REQUEST finishes
-		expect( notifyAcquired ).not.toBeCalled();
-
-		// Await for lock promise fulfillment
-		expect( fulfillment.next( 'promise' ).value.type ).toBe(
-			'AWAIT_PROMISE'
-		);
-
-		// Ensure the promise is fulfilled once GRANT_LOCK_REQUEST finishes
-		expect( notifyAcquired ).toBeCalledWith( lock );
-
-		// Return lock
-		expect( fulfillment.next( lock ) ).toMatchObject( {
-			done: true,
-			value: lock,
-		} );
-	} );
-
-	it( 'Enqueues a lock request and waits until fultillment it when not available', async () => {
-		const fulfillment = __unstableAcquireStoreLock( store, path, {
-			exclusive,
-		} );
-
-		// Start
-		expect( fulfillment.next().value.type ).toBe( 'ENQUEUE_LOCK_REQUEST' );
-
-		// Get pending lock requests
-		expect( fulfillment.next().value.type ).toBe(
-			'PROCESS_PENDING_LOCK_REQUESTS'
-		);
-		expect( fulfillment.next().value.type ).toBe( '@@data/SELECT' );
-
-		// Check if lock may be granted
-		expect( fulfillment.next( [ request ] ).value.type ).toBe(
-			'@@data/SELECT'
-		);
-
-		// Await until lock request is granted
-		expect( fulfillment.next( false ).value.type ).toBe( 'AWAIT_PROMISE' );
-
-		// Ensure the promise isn't fulfilled at this point...
-		expect( notifyAcquired ).not.toBeCalled();
-
-		await sleep( 1000 );
-
-		// ...or even a second lateer
-		expect( notifyAcquired ).not.toBeCalled();
-
-		// Let's assume the promise was fulfilled in the end, the action should return
-		// the lock once that happens.
-		expect( fulfillment.next( lock ) ).toMatchObject( {
-			done: true,
-			value: lock,
-		} );
-	} );
-} );
-
-describe( '__unstableReleaseStoreLock', () => {
-	const lock = { store, path, exclusive: true };
-
-	it( 'Releases a lock request and attempts to fulfill pending lock requests', async () => {
-		const fulfillment = __unstableReleaseStoreLock( lock );
-
-		// Start
-		expect( fulfillment.next().value ).toMatchObject( {
-			type: 'RELEASE_LOCK',
-			lock,
-		} );
-
-		// Attempt to grant any pending lock requests, find none, return
-		expect( fulfillment.next().value.type ).toBe(
-			'PROCESS_PENDING_LOCK_REQUESTS'
-		);
-		expect( fulfillment.next().value.type ).toBe( '@@data/SELECT' );
-
-		// Short-circuit with no results and return
-		expect( fulfillment.next( [] ) ).toMatchObject( {
-			done: true,
-			value: undefined,
-		} );
-	} );
-} );
-
-const sleep = ( ms ) => {
-	const promise = new Promise( ( resolve ) => setTimeout( resolve, ms ) );
-	jest.advanceTimersByTime( ms + 1 );
-	return promise;
-};

package/src/test/integration.js

@@ -1,264 +0,0 @@
-/**
- * WordPress dependencies
- */
-import { createRegistry, controls } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
-import * as actions from '../actions';
-import * as selectors from '../selectors';
-import * as resolvers from '../resolvers';
-import { store } from '../';
-
-// Mock to prevent calling window.fetch in test environment
-jest.mock( '@wordpress/data-controls', () => {
-	const dataControls = jest.requireActual( '@wordpress/data-controls' );
-	return {
-		...dataControls,
-		apiFetch: jest.fn(),
-	};
-} );
-const { apiFetch: actualApiFetch } = jest.requireActual(
-	'@wordpress/data-controls'
-);
-import { apiFetch } from '@wordpress/data-controls';
-
-jest.mock( '@wordpress/api-fetch', () => {
-	return {
-		__esModule: true,
-		default: jest.fn(),
-	};
-} );
-import triggerFetch from '@wordpress/api-fetch';
-
-const runPromise = async ( promise ) => {
-	jest.runAllTimers();
-	await promise;
-};
-
-const runPendingPromises = async () => {
-	jest.runAllTimers();
-	const p = new Promise( ( resolve ) => setTimeout( resolve ) );
-	jest.runAllTimers();
-	await p;
-};
-
-describe( 'receiveEntityRecord', () => {
-	function createTestRegistry( getEntityRecord ) {
-		const registry = createRegistry();
-		const initialState = {
-			entities: {
-				data: {},
-			},
-		};
-		registry.register( store );
-		registry.registerStore( 'test/resolution', {
-			actions: {
-				receiveEntityRecords: actions.receiveEntityRecords,
-				*getEntityRecords( ...args ) {
-					return yield controls.resolveSelect(
-						'test/resolution',
-						'getEntityRecords',
-						...args
-					);
-				},
-				*getEntityRecord( ...args ) {
-					return yield controls.resolveSelect(
-						'test/resolution',
-						'getEntityRecord',
-						...args
-					);
-				},
-			},
-			reducer: ( state = initialState ) => {
-				return state;
-			},
-			selectors: {
-				getEntityRecord: selectors.getEntityRecord,
-				getEntityRecords: selectors.getEntityRecords,
-			},
-			resolvers: {
-				getEntityRecord,
-				getEntityRecords: resolvers.getEntityRecords,
-			},
-		} );
-		return registry;
-	}
-
-	beforeEach( async () => {
-		apiFetch.mockReset();
-		triggerFetch.mockReset();
-		jest.useFakeTimers();
-	} );
-
-	it( 'should not trigger a resolver when the requested record is available via receiveEntityRecords (default entity key).', async () => {
-		const getEntityRecord = jest.fn();
-		const registry = createTestRegistry( getEntityRecord );
-
-		// Trigger resolution of postType records
-		apiFetch.mockImplementation( () => ( {
-			2: { slug: 'test', id: 2 },
-		} ) );
-		await runPromise(
-			registry
-				.dispatch( 'test/resolution' )
-				.getEntityRecords( 'root', 'site' )
-		);
-		jest.runAllTimers();
-
-		// Select record with id = 2, it is available and should not trigger the resolver
-		await runPromise(
-			registry
-				.dispatch( 'test/resolution' )
-				.getEntityRecord( 'root', 'site', 2 )
-		);
-		expect( getEntityRecord ).not.toHaveBeenCalled();
-
-		// Select record with id = 4, it is not available and should trigger the resolver
-		await runPromise(
-			registry
-				.dispatch( 'test/resolution' )
-				.getEntityRecord( 'root', 'site', 4 )
-		);
-		expect( getEntityRecord ).toHaveBeenCalled();
-	} );
-
-	it( 'should not trigger a resolver when the requested record is available via receiveEntityRecords (non-default entity key).', async () => {
-		const getEntityRecord = jest.fn();
-		const registry = createTestRegistry( getEntityRecord );
-
-		// Trigger resolution of postType records
-		apiFetch.mockImplementation( () => ( {
-			'test-1': { slug: 'test-1', id: 2 },
-		} ) );
-		await runPromise(
-			registry
-				.dispatch( 'test/resolution' )
-				.getEntityRecords( 'root', 'taxonomy' )
-		);
-		jest.runAllTimers();
-
-		// Select record with id = test-1, it is available and should not trigger the resolver
-		await runPromise(
-			registry
-				.dispatch( 'test/resolution' )
-				.getEntityRecord( 'root', 'taxonomy', 'test-1' )
-		);
-		expect( getEntityRecord ).not.toHaveBeenCalled();
-
-		// Select record with id = test-2, it is not available and should trigger the resolver
-		await runPromise(
-			registry
-				.dispatch( 'test/resolution' )
-				.getEntityRecord( 'root', 'taxonomy', 'test-2' )
-		);
-		expect( getEntityRecord ).toHaveBeenCalled();
-	} );
-} );
-
-describe( 'saveEntityRecord', () => {
-	function createTestRegistry() {
-		const registry = createRegistry();
-		registry.register( store );
-		return registry;
-	}
-
-	beforeEach( async () => {
-		apiFetch.mockReset();
-		triggerFetch.mockReset();
-		jest.useFakeTimers( 'modern' );
-	} );
-
-	it( 'should not trigger any GET requests until POST/PUT is finished.', async () => {
-		const registry = createTestRegistry();
-		// Fetch post types from the API {{{
-		apiFetch.mockImplementation( () => ( {
-			'post-1': { slug: 'post-1' },
-		} ) );
-
-		// Trigger fetch
-		registry.select( 'core' ).getEntityRecords( 'root', 'postType' );
-		jest.runAllTimers();
-		await Promise.resolve().then( () => jest.runAllTimers() );
-		expect( apiFetch ).toBeCalledTimes( 1 );
-		expect( apiFetch ).toBeCalledWith( {
-			path: '/wp/v2/types?context=edit',
-		} );
-
-		// Select fetched results, there should be no subsequent request
-		apiFetch.mockReset();
-		const results = registry
-			.select( 'core' )
-			.getEntityRecords( 'root', 'postType' );
-		expect( apiFetch ).toBeCalledTimes( 0 );
-		jest.runAllTimers();
-		expect( apiFetch ).toBeCalledTimes( 0 );
-		expect( results ).toHaveLength( 1 );
-		expect( results[ 0 ].slug ).toBe( 'post-1' );
-		// }}} Fetch post types from the API
-
-		// Save changes
-		apiFetch.mockClear();
-		apiFetch.mockImplementation( actualApiFetch );
-		let resolvePromise;
-		triggerFetch.mockImplementation( function () {
-			return new Promise( ( resolve ) => {
-				resolvePromise = resolve;
-			} );
-		} );
-		const savePromise = registry
-			.dispatch( 'core' )
-			.saveEntityRecord( 'root', 'postType', {
-				slug: 'post-1',
-				newField: 'a',
-			} );
-		await runPendingPromises();
-
-		// There should ONLY be a single hanging API call (PUT) by this point.
-		// If there have been any other requests, it is a race condition of some sorts,
-		// e.g. a resolution was triggered before the save was finished.
-		expect( triggerFetch ).toBeCalledTimes( 1 );
-		expect( triggerFetch ).toHaveBeenCalledWith(
-			expect.objectContaining( {
-				method: 'PUT',
-				path: '/wp/v2/types/post-1',
-				data: expect.objectContaining( {
-					newField: 'a',
-					slug: 'post-1',
-				} ),
-			} )
-		);
-		triggerFetch.mockClear();
-		apiFetch.mockClear();
-
-		// The PUT is still hanging, let's call a selector now and make sure it won't trigger
-		// any requests
-		registry.select( 'core' ).getEntityRecords( 'root', 'postType' );
-		jest.runAllTimers();
-		expect( triggerFetch ).toBeCalledTimes( 0 );
-
-		// Now that all timers are exhausted, let's resolve the PUT request and wait until the
-		// save is complete
-		resolvePromise( { newField: 'a', slug: 'post-1' } );
-
-		// Run selector and make sure it doesn't trigger any requests just yet
-		registry.select( 'core' ).getEntityRecords( 'root', 'postType' );
-		jest.runAllTimers();
-		expect( triggerFetch ).toBeCalledTimes( 0 );
-
-		const newRecord = await savePromise;
-		expect( newRecord ).toEqual( { newField: 'a', slug: 'post-1' } );
-		// There should be no other API calls just because saving succeeded
-		jest.runAllTimers();
-		expect( triggerFetch ).toBeCalledTimes( 0 );
-
-		// Calling the selector after the save is finished should trigger a resolver and a GET request
-		registry.select( 'core' ).getEntityRecords( 'root', 'postType' );
-		await runPendingPromises();
-		expect( triggerFetch ).toBeCalledTimes( 1 );
-		expect( triggerFetch ).toBeCalledWith( {
-			path: '/wp/v2/types?context=edit',
-		} );
-	} );
-} );

package/src/utils/if-not-resolved.js

@@ -1,40 +0,0 @@
-/**
- * WordPress dependencies
- */
-import { controls } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
-import { STORE_NAME } from '../name';
-
-/**
- * Higher-order function which invokes the given resolver only if it has not
- * already been resolved with the arguments passed to the enhanced function.
- *
- * This only considers resolution state, and notably does not support resolver
- * custom `isFulfilled` behavior.
- *
- * @param {Function} resolver     Original resolver.
- * @param {string}   selectorName Selector name associated with resolver.
- *
- * @return {Function} Enhanced resolver.
- */
-const ifNotResolved = ( resolver, selectorName ) =>
-	/**
-	 * @param {...any} args Original resolver arguments.
-	 */
-	function* resolveIfNotResolved( ...args ) {
-		const hasStartedResolution = yield controls.select(
-			STORE_NAME,
-			'hasStartedResolution',
-			selectorName,
-			args
-		);
-
-		if ( ! hasStartedResolution ) {
-			yield* resolver( ...args );
-		}
-	};
-
-export default ifNotResolved;

package/src/utils/test/if-not-resolved.js

@@ -1,75 +0,0 @@
-/**
- * WordPress dependencies
- */
-import { controls } from '@wordpress/data';
-
-/**
- * Internal dependencies
- */
-import ifNotResolved from '../if-not-resolved';
-
-jest.mock( '@wordpress/data', () => ( {
-	controls: {
-		select: jest.fn(),
-	},
-} ) );
-
-describe( 'ifNotResolved', () => {
-	beforeEach( () => {
-		controls.select.mockReset();
-	} );
-
-	it( 'returns a new function', () => {
-		const originalResolver = () => {};
-
-		const resolver = ifNotResolved( originalResolver, 'originalResolver' );
-
-		expect( resolver ).toBeInstanceOf( Function );
-	} );
-
-	it( 'triggers original resolver if not already resolved', () => {
-		controls.select.mockImplementation( ( _storeKey, selectorName ) => ( {
-			_nextValue:
-				selectorName === 'hasStartedResolution' ? false : undefined,
-		} ) );
-
-		const originalResolver = jest
-			.fn()
-			.mockImplementation( function* () {} );
-
-		const resolver = ifNotResolved( originalResolver, 'originalResolver' );
-
-		const runResolver = resolver();
-
-		let next, nextValue;
-		do {
-			next = runResolver.next( nextValue );
-			nextValue = next.value?._nextValue;
-		} while ( ! next.done );
-
-		expect( originalResolver ).toHaveBeenCalledTimes( 1 );
-	} );
-
-	it( 'does not trigger original resolver if already resolved', () => {
-		controls.select.mockImplementation( ( _storeKey, selectorName ) => ( {
-			_nextValue:
-				selectorName === 'hasStartedResolution' ? true : undefined,
-		} ) );
-
-		const originalResolver = jest
-			.fn()
-			.mockImplementation( function* () {} );
-
-		const resolver = ifNotResolved( originalResolver, 'originalResolver' );
-
-		const runResolver = resolver();
-
-		let next, nextValue;
-		do {
-			next = runResolver.next( nextValue );
-			nextValue = next.value?._nextValue;
-		} while ( ! next.done );
-
-		expect( originalResolver ).toHaveBeenCalledTimes( 0 );
-	} );
-} );