Changeset 63002 for trunk/tests/phpunit/tests/ajax/wpAjaxImageEditor.php

Timestamp:

08/04/2026 01:56:04 AM (2 months ago)

Author:

westonruter

Message:

Media: Normalize unusable sizes attachment metadata.

Attachment metadata is untyped, and the sizes key is not guaranteed to be present or to hold an array. Sub-size generation can leave it out entirely, and a plugin filtering wp_get_attachment_metadata can replace it with anything. wp_save_image() validated only that the metadata itself was an array before passing $meta['sizes'] to array_merge(), so an absent or scalar value raised a TypeError and the image editor returned an HTTP 500 mid-save. wp_restore_image() had the same gap at $meta['sizes'][ $default_size ] = $data, where a string raises "Cannot use a scalar value as an array" and false is deprecated as of PHP 8.1 and an error as of PHP 9.

wp_get_attachment_metadata() now returns false whenever the metadata is not an array, on the $unfiltered path as well as after the filter, matching the documented array|false return. A sizes key holding a non-array is replaced with an empty array, so every caller can rely on the key being an array whenever it is present. The key is not invented when it is absent: audio, video and document attachments legitimately store metadata without it, and callers such as wp-admin/post.php read the metadata unfiltered in order to modify it and write it back, so normalizing there would persist into the database.

The image editor entry points fill in the missing key themselves, and wp_prepare_attachment_for_js() now checks the dimensions of the full entry alongside its filename before reading them, removing the "Undefined array key" warnings raised for a sizes array that carries no usable full size. PHPUnit coverage is added for all three functions.

Developed in ​https://github.com/WordPress/wordpress-develop/pull/12744.
Follow-up to r11965, r23873, r38949, r49084, r62978.

Props josephscott, westonruter, mukesh27, irozum, ugyensupport, nazmulasif.
See #65686, #64898.
Fixes #65748.

File:

• trunk/tests/phpunit/tests/ajax/wpAjaxImageEditor.php (modified) (1 diff)

trunk/tests/phpunit/tests/ajax/wpAjaxImageEditor.php

@@ -195 +195 @@
                 $this->assertSameSetsWithIndex( $pre_file_sizes, $post_restore_file_sizes, 'Filesize should have restored after restoring the original image.' );
         }
+
+        /**
+         * Ensure editing an image does not fatal when the attachment metadata has no usable `sizes` data.
+         *
+         * Attachment metadata is not guaranteed to contain a `sizes` array. It can be missing when
+         * sub-size generation never ran or failed (for example `wp_create_image_subsizes()` returns an
+         * empty array when the file cannot be parsed), or when it is removed by a plugin filtering
+         * `wp_get_attachment_metadata`. `wp_save_image()` only validates that the metadata itself is an
+         * array, then passes `$meta['sizes']` straight to `array_merge()`.
+         *
+         * @ticket 65748
+         *
+         * @covers ::wp_save_image
+         *
+         * @dataProvider data_save_image_with_unusable_sizes_metadata
+         *
+         * @param array{ sizes?: mixed } $meta Attachment metadata to store before editing, minus the file-specific keys.
+         */
+        public function test_save_image_with_unusable_sizes_metadata( array $meta ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $filename = DIR_TESTDATA . '/images/canola.jpg';
+                $contents = file_get_contents( $filename );
+                $this->assertIsString( $contents );
+
+                $upload = wp_upload_bits( wp_basename( $filename ), null, $contents );
+                $id     = $this->_make_attachment( $upload );
+                $this->assertIsInt( $id );
+
+                $original_meta = wp_get_attachment_metadata( $id );
+                $this->assertIsArray( $original_meta );
+
+                // Keep the real file/dimension data, only make `sizes` unusable.
+                $meta = array_merge(
+                        wp_array_slice_assoc( $original_meta, array( 'width', 'height', 'file', 'filesize' ) ),
+                        $meta
+                );
+
+                wp_update_attachment_metadata( $id, $meta );
+
+                $_REQUEST['action']  = 'image-editor';
+                $_REQUEST['context'] = 'edit-attachment';
+                $_REQUEST['postid']  = $id;
+                $_REQUEST['target']  = 'all';
+                $_REQUEST['do']      = 'save';
+                $_REQUEST['history'] = '[{"c":{"x":5,"y":8,"w":289,"h":322}}]';
+
+                $ret = wp_save_image( $id );
+
+                $this->assertObjectNotHasProperty( 'error', $ret, 'Saving the image should not have returned an error.' );
+
+                $saved_meta = wp_get_attachment_metadata( $id );
+
+                $this->assertIsArray( $saved_meta, 'The saved attachment metadata should be an array.' );
+                $this->assertArrayHasKey( 'sizes', $saved_meta );
+                $this->assertIsArray( $saved_meta['sizes'], 'The saved attachment metadata should contain a `sizes` array.' );
+                $this->assertArrayHasKey( 'thumbnail', $saved_meta['sizes'], 'The edited image should have regenerated the thumbnail size.' );
+        }
+
+        /**
+         * Ensure restoring an image does not fatal when the attachment metadata has no usable `sizes` data.
+         *
+         * `wp_restore_image()` writes each backed up size with `$meta['sizes'][ $default_size ] = $data`
+         * without ever checking that `$meta['sizes']` is an array. A scalar value raises
+         * "Cannot use a scalar value as an array", and `false` is deprecated as of PHP 8.1 and
+         * an error as of PHP 9. The same metadata that fatals `wp_save_image()` reaches this code.
+         *
+         * @ticket 65748
+         *
+         * @covers ::wp_restore_image
+         *
+         * @dataProvider data_save_image_with_unusable_sizes_metadata
+         *
+         * @param array{ sizes?: mixed } $meta Replacement `sizes` metadata to store before restoring.
+         */
+        public function test_restore_image_with_unusable_sizes_metadata( array $meta ) {
+                require_once ABSPATH . 'wp-admin/includes/image-edit.php';
+
+                $filename = DIR_TESTDATA . '/images/canola.jpg';
+                $contents = file_get_contents( $filename );
+                $this->assertIsString( $contents );
+
+                $upload = wp_upload_bits( wp_basename( $filename ), null, $contents );
+                $id     = $this->_make_attachment( $upload );
+                $this->assertIsInt( $id );
+
+                $_REQUEST['action']  = 'image-editor';
+                $_REQUEST['context'] = 'edit-attachment';
+                $_REQUEST['postid']  = $id;
+                $_REQUEST['target']  = 'all';
+                $_REQUEST['do']      = 'save';
+                $_REQUEST['history'] = '[{"c":{"x":5,"y":8,"w":289,"h":322}}]';
+
+                // Edit the image first so that `_wp_attachment_backup_sizes` holds the original sizes.
+                wp_save_image( $id );
+
+                $this->assertNotEmpty(
+                        get_post_meta( $id, '_wp_attachment_backup_sizes', true ),
+                        'The image edit should have stored backup sizes to restore from.'
+                );
+
+                // Keep the metadata written by the edit, only make `sizes` unusable.
+                $edited_meta = wp_get_attachment_metadata( $id );
+                $this->assertIsArray( $edited_meta );
+                unset( $edited_meta['sizes'] );
+
+                wp_update_attachment_metadata( $id, array_merge( $edited_meta, $meta ) );
+
+                wp_restore_image( $id );
+
+                $restored_meta = wp_get_attachment_metadata( $id );
+                $this->assertIsArray( $restored_meta );
+
+                $this->assertArrayHasKey( 'sizes', $restored_meta );
+                $this->assertIsArray( $restored_meta['sizes'], 'The restored attachment metadata should contain a `sizes` array.' );
+                $this->assertArrayHasKey( 'thumbnail', $restored_meta['sizes'], 'The restored image should have the thumbnail size restored from the backup sizes.' );
+        }
+
+        /**
+         * Data provider.
+         *
+         * @return array<non-empty-string, array{ 0: array{ sizes?: mixed } }>
+         */
+        public function data_save_image_with_unusable_sizes_metadata(): array {
+                return array(
+                        'no sizes key'  => array( array() ),
+                        'null sizes'    => array( array( 'sizes' => null ) ),
+                        'empty string'  => array( array( 'sizes' => '' ) ),
+                        'string sizes'  => array( array( 'sizes' => 'not-an-array' ) ),
+                        'boolean sizes' => array( array( 'sizes' => false ) ),
+                );
+        }
 }