Media: Prepare the attachment finalize response from the current post data.

`finalize_item()` prepares its response from the `$post` fetched before the `wp_generate_attachment_metadata` filter runs, so anything a callback writes to the post row is missing from the response. The editor now stores that response as the attachment record instead of refetching, so re-read the post after the metadata is written and return the `WP_Error` if a callback deleted the attachment. See WordPress/gutenberg#81844 and WordPress/gutenberg#81947.

Reviewed by joedolson.
Merges [63564] to the 7.1 branch.

Props gregbenz, andrewserong.
Fixes #66056.i



git-svn-id: https://develop.svn.wordpress.org/branches/7.1@63572 602fd350-edb4-49c9-b593-d223f7449a82

Author: adamsilverstein

src/wp-includes/rest-api/endpoints/class-wp-rest-attachments-controller.php

@@ -3453,6 +3453,21 @@ public function finalize_item( WP_REST_Request $request ) {
 			$response_request['_fields'] = $request['_fields'];
 		}
 
+		/*
+		 * Re-read the post. The 'wp_generate_attachment_metadata' filter above
+		 * runs long after $post was fetched, and a callback that rewrites the
+		 * post row - an optimizer changing post_mime_type once it has
+		 * converted the file, say - would otherwise be missing from this
+		 * response. The editor stores the response as its copy of the record
+		 * rather than reading the attachment again, so a stale row here is
+		 * what it keeps. A callback that deleted the attachment instead leaves
+		 * nothing to respond with, so that is reported as the error it is.
+		 */
+		$post = $this->get_post( $attachment_id );
+		if ( is_wp_error( $post ) ) {
+			return $post;
+		}
+
 		return $this->prepare_item_for_response( $post, $response_request );
 	}
 }

tests/phpunit/tests/rest-api/rest-attachments-controller.php

@@ -5128,6 +5128,204 @@ public function test_finalize_preserves_image_meta(): void {
 		$this->assertSame( $original_image_meta['iso'], $metadata['image_meta']['iso'], 'ISO should be preserved.' );
 	}
 
+	/**
+	 * Verifies that the finalize response carries the generated sub-sizes.
+	 *
+	 * The response is prepared after the sub-size metadata has been written, so
+	 * it is the finished attachment record. The editor stores it as-is instead
+	 * of fetching the attachment again to pick the sizes up.
+	 *
+	 * @ticket 66056
+	 *
+	 * @covers WP_REST_Attachments_Controller::finalize_item
+	 */
+	public function test_finalize_response_contains_generated_sub_sizes(): void {
+		$this->enable_client_side_media_processing();
+
+		wp_set_current_user( self::$author_id );
+
+		$request = new WP_REST_Request( 'POST', '/wp/v2/media' );
+		$request->set_header( 'Content-Type', 'image/jpeg' );
+		$request->set_header( 'Content-Disposition', 'attachment; filename=finalize-response-test.jpg' );
+		$request->set_param( 'generate_sub_sizes', false );
+		$request->set_body( (string) file_get_contents( DIR_TESTDATA . '/images/canola.jpg' ) );
+
+		$response      = rest_get_server()->dispatch( $request );
+		$data          = $response->get_data();
+		$attachment_id = $data['id'];
+
+		// Nothing has generated sub-sizes yet, which is the window in which the
+		// editor's first read of the attachment happens.
+		$this->assertEmpty(
+			(array) $data['media_details']['sizes'],
+			'The create response should not carry sub-sizes yet.'
+		);
+
+		$request = new WP_REST_Request( 'POST', "/wp/v2/media/{$attachment_id}/sideload" );
+		$request->set_header( 'Content-Type', 'image/jpeg' );
+		$request->set_header( 'Content-Disposition', 'attachment; filename=finalize-response-test-150x150.jpg' );
+		$request->set_param( 'image_size', 'thumbnail' );
+		$request->set_body( (string) file_get_contents( DIR_TESTDATA . '/images/test-image.jpg' ) );
+
+		$response       = rest_get_server()->dispatch( $request );
+		$thumbnail_data = $response->get_data();
+		$this->assertSame( 200, $response->get_status(), 'Sideloading the thumbnail should succeed.' );
+
+		$request = new WP_REST_Request( 'POST', "/wp/v2/media/{$attachment_id}/finalize" );
+		$request->set_param( 'sub_sizes', array( $thumbnail_data ) );
+
+		$response = rest_get_server()->dispatch( $request );
+		$this->assertSame( 200, $response->get_status() );
+
+		$data = $response->get_data();
+		$this->assertArrayHasKey( 'media_details', $data );
+		$this->assertArrayHasKey(
+			'thumbnail',
+			$data['media_details']['sizes'],
+			'The finalize response should list the sideloaded sub-size.'
+		);
+
+		// source_url is what the Image block's Resolution control offers.
+		$this->assertArrayHasKey(
+			'source_url',
+			$data['media_details']['sizes']['thumbnail'],
+			'Each sub-size in the finalize response should carry its URL.'
+		);
+		$this->assertStringEndsWith(
+			'finalize-response-test-150x150.jpg',
+			$data['media_details']['sizes']['thumbnail']['source_url']
+		);
+
+		// The finalize response must match what a later read would return, as
+		// the editor stores it in place of that read.
+		$request = new WP_REST_Request( 'GET', "/wp/v2/media/{$attachment_id}" );
+		$request->set_param( 'context', 'view' );
+		$fetched = rest_get_server()->dispatch( $request )->get_data();
+
+		$this->assertSame(
+			array_keys( (array) $fetched['media_details']['sizes'] ),
+			array_keys( (array) $data['media_details']['sizes'] ),
+			'The finalize response should carry the same sizes a refetch would.'
+		);
+	}
+
+	/**
+	 * Verifies that the finalize response reflects the post row as it stands
+	 * after the metadata has been generated.
+	 *
+	 * finalize_item() applies the 'wp_generate_attachment_metadata' filter
+	 * before preparing its response, and a callback is free to rewrite the
+	 * attachment's post row - an optimizer that converts the file updates
+	 * post_mime_type, for instance. The editor stores this response as its
+	 * copy of the record rather than reading the attachment again, so
+	 * anything stale here is what the block keeps for the session.
+	 *
+	 * @ticket 66056
+	 *
+	 * @covers WP_REST_Attachments_Controller::finalize_item
+	 */
+	public function test_finalize_response_reflects_post_row_changed_by_metadata_filter(): void {
+		$this->enable_client_side_media_processing();
+
+		wp_set_current_user( self::$author_id );
+
+		$request = new WP_REST_Request( 'POST', '/wp/v2/media' );
+		$request->set_header( 'Content-Type', 'image/jpeg' );
+		$request->set_header( 'Content-Disposition', 'attachment; filename=filtered-post-row.jpg' );
+		$request->set_param( 'generate_sub_sizes', false );
+		$request->set_param( 'title', 'Original title' );
+		$request->set_body( (string) file_get_contents( DIR_TESTDATA . '/images/canola.jpg' ) );
+
+		$attachment_id = rest_get_server()->dispatch( $request )->get_data()['id'];
+
+		$request = new WP_REST_Request( 'POST', "/wp/v2/media/{$attachment_id}/sideload" );
+		$request->set_header( 'Content-Type', 'image/jpeg' );
+		$request->set_header( 'Content-Disposition', 'attachment; filename=filtered-post-row-150x150.jpg' );
+		$request->set_param( 'image_size', 'thumbnail' );
+		$request->set_body( (string) file_get_contents( DIR_TESTDATA . '/images/test-image.jpg' ) );
+
+		$thumbnail_data = rest_get_server()->dispatch( $request )->get_data();
+
+		// Stands in for a plugin that rewrites the post row as the metadata is
+		// generated. Added after the upload so only finalize runs it.
+		add_filter(
+			'wp_generate_attachment_metadata',
+			static function ( $metadata, $id ) {
+				wp_update_post(
+					array(
+						'ID'         => $id,
+						'post_title' => 'Rewritten while generating metadata',
+					)
+				);
+				return $metadata;
+			},
+			10,
+			2
+		);
+
+		$request = new WP_REST_Request( 'POST', "/wp/v2/media/{$attachment_id}/finalize" );
+		$request->set_param( 'sub_sizes', array( $thumbnail_data ) );
+
+		$response = rest_get_server()->dispatch( $request );
+		$this->assertSame( 200, $response->get_status() );
+
+		$this->assertSame(
+			'Rewritten while generating metadata',
+			get_post( $attachment_id )->post_title,
+			'The filter should have rewritten the stored post row.'
+		);
+
+		$this->assertSame(
+			'Rewritten while generating metadata',
+			$response->get_data()['title']['raw'],
+			'The finalize response should carry the rewritten post row, not the row as it was before the metadata was generated.'
+		);
+	}
+
+	/**
+	 * Verifies that finalize fails when the attachment no longer exists by the
+	 * time its response is prepared.
+	 *
+	 * A 'wp_generate_attachment_metadata' callback that rejects the file and
+	 * deletes the attachment must not be answered with a 200 built from the row
+	 * as it was before the callback ran: the editor would store that stale
+	 * record and report the upload as complete.
+	 *
+	 * @ticket 66056
+	 *
+	 * @covers WP_REST_Attachments_Controller::finalize_item
+	 */
+	public function test_finalize_fails_when_metadata_filter_deletes_attachment(): void {
+		$this->enable_client_side_media_processing();
+
+		wp_set_current_user( self::$author_id );
+
+		$request = new WP_REST_Request( 'POST', '/wp/v2/media' );
+		$request->set_header( 'Content-Type', 'image/jpeg' );
+		$request->set_header( 'Content-Disposition', 'attachment; filename=deleted-while-finalizing.jpg' );
+		$request->set_param( 'generate_sub_sizes', false );
+		$request->set_body( (string) file_get_contents( DIR_TESTDATA . '/images/canola.jpg' ) );
+
+		$attachment_id = rest_get_server()->dispatch( $request )->get_data()['id'];
+
+		add_filter(
+			'wp_generate_attachment_metadata',
+			static function ( $metadata, $id ) {
+				wp_delete_attachment( $id, true );
+				return $metadata;
+			},
+			10,
+			2
+		);
+
+		$request = new WP_REST_Request( 'POST', "/wp/v2/media/{$attachment_id}/finalize" );
+		$request->set_param( 'sub_sizes', array() );
+
+		$response = rest_get_server()->dispatch( $request );
+
+		$this->assertErrorResponse( 'rest_post_invalid_id', $response, 404 );
+	}
+
 	/**
 	 * Tests that the sideload route declares `convert_format` as a boolean arg.
 	 *