@wordpress/editor 12.2.0 → 12.2.2

package/src/store/test/actions.js

@@ -1,461 +1,289 @@
 /**
  * WordPress dependencies
  */
-import { apiFetch } from '@wordpress/data-controls';
-import { controls } from '@wordpress/data';
+import apiFetch from '@wordpress/api-fetch';
+import { store as blockEditorStore } from '@wordpress/block-editor';
+import { store as coreStore } from '@wordpress/core-data';
+import { createRegistry } from '@wordpress/data';
 import { store as noticesStore } from '@wordpress/notices';
 
 /**
  * Internal dependencies
  */
+
 import * as actions from '../actions';
-import { STORE_NAME, TRASH_POST_NOTICE_ID } from '../constants';
+import { store as editorStore } from '..';
+
+jest.useRealTimers();
+
+const postId = 44;
 
-const postType = {
+const postTypeConfig = {
+	kind: 'postType',
+	name: 'post',
+	baseURL: '/wp/v2/posts',
+	transientEdits: { blocks: true, selection: true },
+	mergedEdits: { meta: true },
+	rawAttributes: [ 'title', 'excerpt', 'content' ],
+};
+
+const postTypeEntity = {
+	slug: 'post',
 	rest_base: 'posts',
 	labels: {
 		item_updated: 'Updated Post',
 		item_published: 'Post published',
+		item_reverted_to_draft: 'Post reverted to draft.',
 	},
 };
-const postId = 44;
-const postTypeSlug = 'post';
 
-describe( 'Post generator actions', () => {
+function createRegistryWithStores() {
+	// create a registry
+	const registry = createRegistry();
+
+	// register stores
+	registry.register( blockEditorStore );
+	registry.register( coreStore );
+	registry.register( editorStore );
+	registry.register( noticesStore );
+
+	// register post type entity
+	registry.dispatch( coreStore ).addEntities( [ postTypeConfig ] );
+
+	// store post type entity
+	registry
+		.dispatch( coreStore )
+		.receiveEntityRecords( 'root', 'postType', [ postTypeEntity ] );
+
+	return registry;
+}
+
+const getMethod = ( options ) =>
+	options.headers?.[ 'X-HTTP-Method-Override' ] || options.method || 'GET';
+
+describe( 'Post actions', () => {
 	describe( 'savePost()', () => {
-		let fulfillment, currentPost, currentPostStatus, isAutosave;
-		beforeEach( () => {
-			currentPost = () => ( {
+		it( 'saves a modified post', async () => {
+			const post = {
 				id: postId,
-				type: postTypeSlug,
+				type: 'post',
 				title: 'bar',
 				content: 'bar',
 				excerpt: 'crackers',
-				status: currentPostStatus,
-			} );
-		} );
-		const reset = ( isAutosaving ) =>
-			( fulfillment = actions.savePost( { isAutosave: isAutosaving } ) );
-		const testConditions = [
-			[
-				'yields an action for checking if the post is saveable',
-				() => true,
-				() => {
-					reset( isAutosave );
-					const { value } = fulfillment.next();
-					expect( value ).toEqual(
-						controls.select( STORE_NAME, 'isEditedPostSaveable' )
-					);
-				},
-			],
-			[
-				'yields an action for selecting the current edited post content',
-				() => true,
-				() => {
-					const { value } = fulfillment.next( true );
-					expect( value ).toEqual(
-						controls.select( STORE_NAME, 'getEditedPostContent' )
-					);
-				},
-			],
-			[
-				"yields an action for editing the post entity's content if not an autosave",
-				() => true,
-				() => {
-					if ( ! isAutosave ) {
-						const edits = { content: currentPost().content };
-						const { value } = fulfillment.next( edits.content );
-						expect( value ).toEqual(
-							controls.dispatch( STORE_NAME, 'editPost', edits, {
-								undoIgnore: true,
-							} )
-						);
-					}
-				},
-			],
-			[
-				'yields an action for signalling that an update to the post started',
-				() => true,
-				() => {
-					const { value } = fulfillment.next();
-					expect( value ).toEqual( {
-						type: 'REQUEST_POST_UPDATE_START',
-						options: { isAutosave },
-					} );
-				},
-			],
-			[
-				'yields an action for selecting the current post',
-				() => true,
-				() => {
-					const { value } = fulfillment.next();
-					expect( value ).toEqual(
-						controls.select( STORE_NAME, 'getCurrentPost' )
-					);
-				},
-			],
-			[
-				"yields an action for selecting the post entity's non transient edits",
-				() => true,
-				() => {
-					const post = currentPost();
-					const { value } = fulfillment.next( post );
-					expect( value ).toEqual(
-						controls.select(
-							'core',
-							'getEntityRecordNonTransientEdits',
-							'postType',
-							post.type,
-							post.id
-						)
-					);
-				},
-			],
-			[
-				'yields an action for dispatching an update to the post entity',
-				() => true,
-				() => {
-					const post = currentPost();
-					const { value } = fulfillment.next( post );
-					expect( value ).toEqual(
-						controls.dispatch(
-							'core',
-							'saveEntityRecord',
-							'postType',
-							post.type,
-							isAutosave ? { ...post, content: undefined } : post,
-							{
-								isAutosave,
-							}
-						)
-					);
-				},
-			],
-			[
-				'yields an action for signalling that an update to the post finished',
-				() => true,
-				() => {
-					const { value } = fulfillment.next();
-					expect( value ).toEqual( {
-						type: 'REQUEST_POST_UPDATE_FINISH',
-						options: { isAutosave },
-					} );
-				},
-			],
-			[
-				"yields an action for selecting the entity's save error",
-				() => true,
-				() => {
-					const post = currentPost();
-					const { value } = fulfillment.next();
-					expect( value ).toEqual(
-						controls.select(
-							'core',
-							'getLastEntitySaveError',
-							'postType',
-							post.type,
-							post.id
-						)
-					);
-				},
-			],
-			[
-				'yields an action for selecting the current post',
-				() => true,
-				() => {
-					const { value } = fulfillment.next();
-					expect( value ).toEqual(
-						controls.select( STORE_NAME, 'getCurrentPost' )
-					);
-				},
-			],
-			[
-				'yields an action for selecting the current post type config',
-				() => true,
-				() => {
-					const post = currentPost();
-					const { value } = fulfillment.next( post );
-					expect( value ).toEqual(
-						controls.resolveSelect(
-							'core',
-							'getPostType',
-							post.type
-						)
-					);
-				},
-			],
-			[
-				'yields an action for dispatching a success notice',
-				() => true,
-				() => {
-					if ( ! isAutosave ) {
-						const { value } = fulfillment.next( postType );
-						expect( value ).toEqual(
-							controls.dispatch(
-								noticesStore,
-								'createSuccessNotice',
-								currentPostStatus === 'publish'
-									? 'Updated Post'
-									: 'Draft saved',
-								{
-									actions: [],
-									id: 'SAVE_POST_NOTICE_ID',
-									type: 'snackbar',
-								}
-							)
-						);
-					}
-				},
-			],
-			[
-				'yields an action for marking the last change as persistent',
-				() => true,
-				() => {
-					if ( ! isAutosave ) {
-						const { value } = fulfillment.next();
-						expect( value ).toEqual(
-							controls.dispatch(
-								'core/block-editor',
-								'__unstableMarkLastChangeAsPersistent'
-							)
-						);
-					}
-				},
-			],
-			[
-				'implicitly returns undefined',
-				() => true,
-				() => {
-					expect( fulfillment.next() ).toEqual( {
-						done: true,
-						value: undefined,
-					} );
-				},
-			],
-		];
-
-		const conditionalRunTestRoutine = ( isAutosaving ) => ( [
-			testDescription,
-			shouldRun,
-			testRoutine,
-		] ) => {
-			if ( shouldRun( isAutosaving ) ) {
-				// eslint-disable-next-line jest/valid-title
-				it( testDescription, () => {
-					testRoutine();
-				} );
-			}
-		};
-
-		describe( 'yields with expected responses for when not autosaving and edited post is new', () => {
-			beforeEach( () => {
-				isAutosave = false;
-				currentPostStatus = 'draft';
-			} );
-			testConditions.forEach( conditionalRunTestRoutine( false ) );
-		} );
+				status: 'draft',
+			};
+
+			// mock apiFetch response
+			apiFetch.setFetchHandler( async ( options ) => {
+				const method = getMethod( options );
+				const { path, data } = options;
 
-		describe( 'yields with expected responses for when not autosaving and edited post is not new', () => {
-			beforeEach( () => {
-				isAutosave = false;
-				currentPostStatus = 'publish';
+				if (
+					method === 'PUT' &&
+					path.startsWith( `/wp/v2/posts/${ postId }` )
+				) {
+					return { ...post, ...data };
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ method } ${ path }`,
+				};
 			} );
-			testConditions.forEach( conditionalRunTestRoutine( false ) );
-		} );
-		describe( 'yields with expected responses for when autosaving is true and edited post is not new', () => {
-			beforeEach( () => {
-				isAutosave = true;
-				currentPostStatus = 'autosave';
+
+			// create registry
+			const registry = createRegistryWithStores();
+
+			// store post
+			registry
+				.dispatch( coreStore )
+				.receiveEntityRecords( 'postType', 'post', post );
+
+			// setup editor with post and initial edits
+			registry.dispatch( editorStore ).setupEditor( post, {
+				content: 'new bar',
 			} );
-			testConditions.forEach( conditionalRunTestRoutine( true ) );
-		} );
-	} );
-	describe( 'autosave()', () => {
-		it( 'dispatches savePost with the correct arguments', () => {
-			const fulfillment = actions.autosave();
-			const { value } = fulfillment.next();
-			expect( value.actionName ).toBe( 'savePost' );
-			expect( value.args ).toEqual( [ { isAutosave: true } ] );
-		} );
-	} );
-	describe( 'trashPost()', () => {
-		let fulfillment;
-		const currentPost = { id: 10, content: 'foo', status: 'publish' };
-		const reset = () => ( fulfillment = actions.trashPost() );
-		const rewind = () => {
-			reset();
-			fulfillment.next();
-			fulfillment.next( postTypeSlug );
-			fulfillment.next( postType );
-			fulfillment.next();
-			fulfillment.next( currentPost );
-		};
-		it( 'yields expected action for selecting the current post type slug', () => {
-			reset();
-			const { value } = fulfillment.next();
-			expect( value ).toEqual(
-				controls.select( STORE_NAME, 'getCurrentPostType' )
-			);
-		} );
-		it( 'yields expected action for selecting the post type object', () => {
-			const { value } = fulfillment.next( postTypeSlug );
-			expect( value ).toEqual(
-				controls.resolveSelect( 'core', 'getPostType', postTypeSlug )
-			);
-		} );
-		it(
-			'yields expected action for dispatching removing the trash notice ' +
-				'for the post',
-			() => {
-				const { value } = fulfillment.next( postType );
-				expect( value ).toEqual(
-					controls.dispatch(
-						noticesStore,
-						'removeNotice',
-						TRASH_POST_NOTICE_ID
-					)
-				);
-			}
-		);
-		it( 'yields expected action for selecting the currentPost', () => {
-			const { value } = fulfillment.next();
-			expect( value ).toEqual(
-				controls.select( STORE_NAME, 'getCurrentPost' )
-			);
-		} );
-		it( 'yields expected action object for the api fetch', () => {
-			const { value } = fulfillment.next( currentPost );
-			expect( value ).toEqual(
-				apiFetch( {
-					path: `/wp/v2/${ postType.rest_base }/${ currentPost.id }`,
-					method: 'DELETE',
-				} )
+
+			// check that the post is dirty
+			expect( registry.select( editorStore ).isEditedPostDirty() ).toBe(
+				true
 			);
-		} );
-		describe( 'expected yields when fetch throws an error', () => {
-			it( 'yields expected action for dispatching an error notice', () => {
-				const error = { foo: 'bar', code: 'fail' };
-				const { value } = fulfillment.throw( error );
-				expect( value ).toEqual(
-					controls.dispatch(
-						noticesStore,
-						'createErrorNotice',
-						'Trashing failed',
-						{
-							id: TRASH_POST_NOTICE_ID,
-						}
-					)
-				);
-			} );
-		} );
-		describe( 'expected yields when fetch does not throw an error', () => {
-			it( 'yields expected dispatch action for saving the post', () => {
-				rewind();
-				const { value } = fulfillment.next();
-				expect( value ).toEqual(
-					controls.dispatch( STORE_NAME, 'savePost' )
-				);
-			} );
-		} );
-	} );
-} );
 
-describe( 'Editor actions', () => {
-	describe( 'setupEditor()', () => {
-		it( 'should yield the setup editor actions but not reset blocks when the template is empty', () => {
-			const post = { content: { raw: '' }, status: 'publish' };
-			const fulfillment = actions.setupEditor( post );
-			let { value } = fulfillment.next();
-			expect( value ).toEqual( actions.resetPost( post ) );
-			value = fulfillment.next().value;
-			expect( value ).toEqual( {
-				type: 'SETUP_EDITOR',
-				post: { content: { raw: '' }, status: 'publish' },
-			} );
-			value = fulfillment.next().value;
-			expect( value ).toEqual(
-				actions.setupEditorState( {
-					content: { raw: '' },
-					status: 'publish',
-				} )
+			// save the post
+			await registry.dispatch( editorStore ).savePost();
+
+			// check the new content
+			const content = registry
+				.select( editorStore )
+				.getEditedPostContent();
+			expect( content ).toBe( 'new bar' );
+
+			// check that the post is no longer dirty
+			expect( registry.select( editorStore ).isEditedPostDirty() ).toBe(
+				false
 			);
-		} );
-	} );
 
-	describe( 'resetPost', () => {
-		it( 'should return the RESET_POST action', () => {
-			const post = {};
-			const result = actions.resetPost( post );
-			expect( result ).toEqual( {
-				type: 'RESET_POST',
-				post,
-			} );
+			// check that a success notice has been shown
+			const notices = registry.select( noticesStore ).getNotices();
+			expect( notices ).toMatchObject( [
+				{
+					status: 'success',
+					content: 'Draft saved',
+				},
+			] );
 		} );
 	} );
 
-	describe( 'requestPostUpdateStart', () => {
-		it( 'should return the REQUEST_POST_UPDATE_START action', () => {
-			const result = actions.__experimentalRequestPostUpdateStart();
-			expect( result ).toEqual( {
-				type: 'REQUEST_POST_UPDATE_START',
-				options: {},
-			} );
-		} );
-	} );
+	describe( 'autosave()', () => {
+		it( 'autosaves a modified post', async () => {
+			const post = {
+				id: postId,
+				type: 'post',
+				title: 'bar',
+				content: 'bar',
+				excerpt: 'crackers',
+				status: 'draft',
+			};
 
-	describe( 'editPost', () => {
-		it( 'should edit the relevant entity record', () => {
-			const edits = { format: 'sample' };
-			const fulfillment = actions.editPost( edits );
-			expect( fulfillment.next() ).toEqual( {
-				done: false,
-				value: controls.select( STORE_NAME, 'getCurrentPost' ),
-			} );
-			const post = { id: 1, type: 'post' };
-			expect( fulfillment.next( post ) ).toEqual( {
-				done: false,
-				value: controls.dispatch(
-					'core',
-					'editEntityRecord',
-					'postType',
-					post.type,
-					post.id,
-					edits,
-					undefined
-				),
+			// mock apiFetch response
+			apiFetch.setFetchHandler( async ( options ) => {
+				const method = getMethod( options );
+				const { path, data } = options;
+
+				if (
+					method === 'GET' &&
+					path.startsWith( '/wp/v2/users/me' )
+				) {
+					return { id: 1 };
+				} else if (
+					path.startsWith( `/wp/v2/posts/${ postId }/autosaves` )
+				) {
+					if ( method === 'POST' ) {
+						return { ...post, ...data };
+					} else if ( method === 'GET' ) {
+						return [];
+					}
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ method } ${ path }`,
+				};
 			} );
-			expect( fulfillment.next() ).toEqual( {
-				done: true,
-				value: undefined,
+
+			// create registry
+			const registry = createRegistryWithStores();
+
+			// set current user
+			registry.dispatch( coreStore ).receiveCurrentUser( { id: 1 } );
+
+			// store post
+			registry
+				.dispatch( coreStore )
+				.receiveEntityRecords( 'postType', 'post', post );
+
+			// setup editor with post and initial edits
+			registry.dispatch( editorStore ).setupEditor( post, {
+				content: 'new bar',
 			} );
+
+			// check that the post is dirty
+			expect( registry.select( editorStore ).isEditedPostDirty() ).toBe(
+				true
+			);
+
+			// autosave the post
+			await registry.dispatch( editorStore ).autosave();
+
+			// check the new content
+			const content = registry
+				.select( editorStore )
+				.getEditedPostContent();
+			expect( content ).toBe( 'new bar' );
+
+			// check that the post is no longer dirty
+			expect( registry.select( editorStore ).isEditedPostDirty() ).toBe(
+				false
+			);
+
+			// check that no notice has been shown on autosave
+			const notices = registry.select( noticesStore ).getNotices();
+			expect( notices ).toMatchObject( [] );
 		} );
 	} );
 
-	describe( 'redo', () => {
-		it( 'should yield the REDO action', () => {
-			const fulfillment = actions.redo();
-			expect( fulfillment.next() ).toEqual( {
-				done: false,
-				value: controls.dispatch( 'core', 'redo' ),
-			} );
-			expect( fulfillment.next() ).toEqual( {
-				done: true,
-				value: undefined,
+	describe( 'trashPost()', () => {
+		it( 'trashes a post', async () => {
+			const post = {
+				id: postId,
+				type: 'post',
+				content: 'foo',
+				status: 'publish',
+			};
+
+			let gotTrashed = false;
+
+			// mock apiFetch response
+			apiFetch.setFetchHandler( async ( options ) => {
+				const method = getMethod( options );
+				const { path, data } = options;
+
+				if ( path.startsWith( `/wp/v2/posts/${ postId }` ) ) {
+					if ( method === 'DELETE' ) {
+						gotTrashed = true;
+						return { ...post, status: 'trash' };
+					} else if ( method === 'PUT' ) {
+						return {
+							...post,
+							...( gotTrashed && { status: 'trash' } ),
+							...data,
+						};
+					}
+				}
+
+				throw {
+					code: 'unknown_path',
+					message: `Unknown path: ${ path }`,
+				};
 			} );
+
+			// create registry
+			const registry = createRegistryWithStores();
+
+			// store post
+			registry
+				.dispatch( coreStore )
+				.receiveEntityRecords( 'postType', 'post', post );
+
+			// setup editor with post
+			registry.dispatch( editorStore ).setupEditor( post );
+
+			// trash the post
+			await registry.dispatch( editorStore ).trashPost();
+
+			// check that there are no notices
+			const notices = registry.select( noticesStore ).getNotices();
+			expect( notices ).toEqual( [] );
+
+			// check the new status
+			const { status } = registry.select( editorStore ).getCurrentPost();
+			expect( status ).toBe( 'trash' );
 		} );
 	} );
+} );
 
-	describe( 'undo', () => {
-		it( 'should yield the UNDO action', () => {
-			const fulfillment = actions.undo();
-			expect( fulfillment.next() ).toEqual( {
-				done: false,
-				value: controls.dispatch( 'core', 'undo' ),
-			} );
-			expect( fulfillment.next() ).toEqual( {
-				done: true,
-				value: undefined,
-			} );
+describe( 'Editor actions', () => {
+	describe( 'setupEditor()', () => {
+		it( 'should setup the editor', () => {
+			// create registry
+			const registry = createRegistryWithStores();
+
+			registry
+				.dispatch( editorStore )
+				.setupEditor( { id: 10, type: 'post' } );
+			expect( registry.select( editorStore ).getCurrentPostId() ).toBe(
+				10
+			);
 		} );
 	} );