Make WordPress Core

Ticket #20564: 20564.29.diff

File 20564.29.diff, 62.9 KB (added by adamsilverstein, 7 months ago)
  • src/wp-admin/includes/post.php

    diff --git src/wp-admin/includes/post.php src/wp-admin/includes/post.php
    index 8d7f76b3fe..dd447d9beb 100644
    function wp_create_post_autosave( $post_data ) { 
    19701970                 * Fires before an autosave is stored.
    19711971                 *
    19721972                 * @since 4.1.0
     1973                 * @since 6.4.0 The `$is_update` parameter was added to indicate if the autosave is being updated or was newly created.
    19731974                 *
    19741975                 * @param array $new_autosave Post array - the autosave that is about to be saved.
     1976                 * @param bool  $is_update    Whether this is an existing autosave.
    19751977                 */
    1976                 do_action( 'wp_creating_autosave', $new_autosave );
    1977 
     1978                do_action( 'wp_creating_autosave', $new_autosave, true );
    19781979                return wp_update_post( $new_autosave );
    19791980        }
    19801981
    function wp_create_post_autosave( $post_data ) { 
    19821983        $post_data = wp_unslash( $post_data );
    19831984
    19841985        // Otherwise create the new autosave as a special post revision.
    1985         return _wp_put_post_revision( $post_data, true );
     1986        $revision = _wp_put_post_revision( $post_data, true );
     1987
     1988        if ( ! is_wp_error( $revision ) && 0 !== $revision ) {
     1989
     1990                /** This action is documented in wp-admin/includes/post.php */
     1991                do_action( 'wp_creating_autosave', get_post( $revision, ARRAY_A ), false );
     1992        }
     1993
     1994        return $revision;
     1995}
     1996
     1997/**
     1998 * Autosave the revisioned meta fields.
     1999 *
     2000 * Iterates through the revisioned meta fields and checks each to see if they are set,
     2001 * and have a changed value. If so, the meta value is saved and attached to the autosave.
     2002 *
     2003 * @since 6.4.0
     2004 *
     2005 * @param array $new_autosave The new post data being autosaved.
     2006 */
     2007function wp_autosave_post_revisioned_meta_fields( $new_autosave ) {
     2008        /*
     2009         * The post data arrives as either $_POST['data']['wp_autosave'] or the $_POST
     2010         * itself. This sets $posted_data to the correct variable.
     2011         *
     2012         * Ignoring sanitization to avoid altering meta. Ignoring the nonce check because
     2013         * this is hooked on inner core hooks where a valid nonce was already checked.
     2014         *
     2015         * @phpcs:disable WordPress.Security
     2016         */
     2017        $posted_data = isset( $_POST['data']['wp_autosave'] ) ? $_POST['data']['wp_autosave'] : $_POST;
     2018        // phpcs:enable
     2019
     2020        $post_type = get_post_type( $new_autosave['post_parent'] );
     2021
     2022        /*
     2023         * Go thru the revisioned meta keys and save them as part of the autosave, if
     2024         * the meta key is part of the posted data, the meta value is not blank and
     2025         * the the meta value has changes from the last autosaved value.
     2026         */
     2027        foreach ( wp_post_revision_meta_keys( $post_type ) as $meta_key ) {
     2028
     2029                if (
     2030                isset( $posted_data[ $meta_key ] ) &&
     2031                get_post_meta( $new_autosave['ID'], $meta_key, true ) !== wp_unslash( $posted_data[ $meta_key ] )
     2032                ) {
     2033                        /*
     2034                         * Use the underlying delete_metadata() and add_metadata() functions
     2035                         * vs delete_post_meta() and add_post_meta() to make sure we're working
     2036                         * with the actual revision meta.
     2037                         */
     2038                        delete_metadata( 'post', $new_autosave['ID'], $meta_key );
     2039
     2040                        /*
     2041                         * One last check to ensure meta value not empty().
     2042                         */
     2043                        if ( ! empty( $posted_data[ $meta_key ] ) ) {
     2044                                /*
     2045                                 * Add the revisions meta data to the autosave.
     2046                                 */
     2047                                add_metadata( 'post', $new_autosave['ID'], $meta_key, $posted_data[ $meta_key ] );
     2048                        }
     2049                }
     2050        }
    19862051}
    19872052
    19882053/**
  • src/wp-includes/default-filters.php

    diff --git src/wp-includes/default-filters.php src/wp-includes/default-filters.php
    index adba75fcd7..090ee61d51 100644
    add_action( 'plugins_loaded', 'wp_maybe_load_widgets', 0 ); 
    411411add_action( 'plugins_loaded', 'wp_maybe_load_embeds', 0 );
    412412add_action( 'shutdown', 'wp_ob_end_flush_all', 1 );
    413413// Create a revision whenever a post is updated.
     414add_action( 'wp_after_insert_post', 'wp_save_post_revision_on_insert', 9, 3 );
    414415add_action( 'post_updated', 'wp_save_post_revision', 10, 1 );
    415416add_action( 'publish_post', '_publish_post_hook', 5, 1 );
    416417add_action( 'transition_post_status', '_transition_post_status', 5, 3 );
    add_action( 'init', 'wp_register_persisted_preferences_meta' ); 
    719720// CPT wp_block custom postmeta field.
    720721add_action( 'init', 'wp_create_initial_post_meta' );
    721722
     723// Include revisioned meta when considering whether a post revision has changed.
     724add_filter( 'wp_save_post_revision_post_has_changed', 'wp_check_revisioned_meta_fields_have_changed', 10, 3 );
     725
     726// Save revisioned post meta immediately after a revision is saved
     727add_action( '_wp_put_post_revision', 'wp_save_revisioned_meta_fields', 10, 2 );
     728
     729// Include revisioned meta when creating or updating an autosave revision.
     730add_action( 'wp_creating_autosave', 'wp_autosave_post_revisioned_meta_fields' );
     731
     732// When restoring revisions, also restore revisioned meta.
     733add_action( 'wp_restore_post_revision', 'wp_restore_post_revision_meta', 10, 2 );
     734
    722735// Font management.
    723736add_action( 'wp_head', 'wp_print_font_faces', 50 );
    724737
  • src/wp-includes/meta.php

    diff --git src/wp-includes/meta.php src/wp-includes/meta.php
    index 0b9f08544e..96ace4e972 100644
    function sanitize_meta( $meta_key, $meta_value, $object_type, $object_subtype = 
    13671367 * @since 4.9.8 The `$object_subtype` argument was added to the arguments array.
    13681368 * @since 5.3.0 Valid meta types expanded to include "array" and "object".
    13691369 * @since 5.5.0 The `$default` argument was added to the arguments array.
     1370 * @since 6.4.0 The `$revisions_enabled` argument was added to the arguments array.
    13701371 *
    13711372 * @param string       $object_type Type of object metadata is for. Accepts 'post', 'comment', 'term', 'user',
    13721373 *                                  or any other object type with an associated meta table.
    function sanitize_meta( $meta_key, $meta_value, $object_type, $object_subtype = 
    13921393 *                                         support for custom fields for registered meta to be accessible via REST.
    13931394 *                                         When registering complex meta values this argument may optionally be an
    13941395 *                                         array with 'schema' or 'prepare_callback' keys instead of a boolean.
     1396 *     @type bool       $revisions_enabled Whether to enable revisions support for this meta_key. Can only be used when the
     1397 *                                         object type is 'post'.
    13951398 * }
    13961399 * @param string|array $deprecated Deprecated. Use `$args` instead.
    13971400 * @return bool True if the meta key was successfully registered in the global array, false if not.
    function register_meta( $object_type, $meta_key, $args, $deprecated = null ) { 
    14141417                'sanitize_callback' => null,
    14151418                'auth_callback'     => null,
    14161419                'show_in_rest'      => false,
     1420                'revisions_enabled' => false,
    14171421        );
    14181422
    14191423        // There used to be individual args for sanitize and auth callbacks.
    function register_meta( $object_type, $meta_key, $args, $deprecated = null ) { 
    14601464        }
    14611465
    14621466        $object_subtype = ! empty( $args['object_subtype'] ) ? $args['object_subtype'] : '';
     1467        if ( $args['revisions_enabled'] ) {
     1468                if ( 'post' !== $object_type ) {
     1469                        _doing_it_wrong( __FUNCTION__, __( 'Meta keys cannot enable revisions support unless the object type supports revisions.' ), '6.4.0' );
     1470
     1471                        return false;
     1472                } elseif ( ! empty( $object_subtype ) && ! post_type_supports( $object_subtype, 'revisions' ) ) {
     1473                        _doing_it_wrong( __FUNCTION__, __( 'Meta keys cannot enable revisions support unless the object subtype supports revisions.' ), '6.4.0' );
     1474
     1475                        return false;
     1476                }
     1477        }
    14631478
    14641479        // If `auth_callback` is not provided, fall back to `is_protected_meta()`.
    14651480        if ( empty( $args['auth_callback'] ) ) {
  • src/wp-includes/rest-api/endpoints/class-wp-rest-autosaves-controller.php

    diff --git src/wp-includes/rest-api/endpoints/class-wp-rest-autosaves-controller.php src/wp-includes/rest-api/endpoints/class-wp-rest-autosaves-controller.php
    index d2dc249615..fa403e950c 100644
    class WP_REST_Autosaves_Controller extends WP_REST_Revisions_Controller { 
    234234                         */
    235235                        $autosave_id = wp_update_post( wp_slash( (array) $prepared_post ), true );
    236236                } else {
    237                         // Non-draft posts: create or update the post autosave.
    238                         $autosave_id = $this->create_post_autosave( (array) $prepared_post );
     237                        // Non-draft posts: create or update the post autosave. Pass the meta data.
     238                        $autosave_id = $this->create_post_autosave( (array) $prepared_post, (array) $request->get_param( 'meta' ) );
    239239                }
    240240
    241241                if ( is_wp_error( $autosave_id ) ) {
    class WP_REST_Autosaves_Controller extends WP_REST_Revisions_Controller { 
    348348         * From wp-admin/post.php.
    349349         *
    350350         * @since 5.0.0
     351         * @since 6.4.0 The `$meta` parameter was added.
    351352         *
    352353         * @param array $post_data Associative array containing the post data.
     354         * @param array $meta      Associative array containing the post meta data.
    353355         * @return mixed The autosave revision ID or WP_Error.
    354356         */
    355         public function create_post_autosave( $post_data ) {
     357        public function create_post_autosave( $post_data, array $meta = array() ) {
    356358
    357359                $post_id = (int) $post_data['ID'];
    358360                $post    = get_post( $post_id );
    class WP_REST_Autosaves_Controller extends WP_REST_Revisions_Controller { 
    372374                        }
    373375                }
    374376
     377                // Check if meta values have changed.
     378                if ( ! empty( $meta ) ) {
     379                        $revisioned_meta_keys = wp_post_revision_meta_keys( $post->post_type );
     380                        foreach ( $revisioned_meta_keys as $meta_key ) {
     381                                // get_metadata_raw is used to avoid retrieving the default value.
     382                                $old_meta = get_metadata_raw( 'post', $post_id, $meta_key, true );
     383                                $new_meta = isset( $meta[ $meta_key ] ) ? $meta[ $meta_key ] : '';
     384
     385                                if ( $new_meta !== $old_meta ) {
     386                                        $autosave_is_different = true;
     387                                        break;
     388                                }
     389                        }
     390                }
     391
    375392                $user_id = get_current_user_id();
    376393
    377394                // Store one autosave per author. If there is already an autosave, overwrite it.
    class WP_REST_Autosaves_Controller extends WP_REST_Revisions_Controller { 
    390407                        do_action( 'wp_creating_autosave', $new_autosave );
    391408
    392409                        // wp_update_post() expects escaped array.
    393                         return wp_update_post( wp_slash( $new_autosave ) );
     410                        $revision_id = wp_update_post( wp_slash( $new_autosave ) );
     411                } else {
     412                        // Create the new autosave as a special post revision.
     413                        $revision_id = _wp_put_post_revision( $post_data, true );
     414                }
     415
     416                if ( is_wp_error( $revision_id ) || 0 === $revision_id ) {
     417                        return $revision_id;
     418                }
     419
     420                // Attached any passed meta values that have revisions enabled.
     421                if ( ! empty( $meta ) && $revision_id ) {
     422                        foreach ( $revisioned_meta_keys as $meta_key ) {
     423                                if ( isset( $meta[ $meta_key ] ) ) {
     424                                        update_metadata( 'post', $revision_id, $meta_key, $meta[ $meta_key ] );
     425                                }
     426                        }
    394427                }
    395428
    396                 // Create the new autosave as a special post revision.
    397                 return _wp_put_post_revision( $post_data, true );
     429                return $revision_id;
    398430        }
    399431
    400432        /**
  • src/wp-includes/rest-api/endpoints/class-wp-rest-revisions-controller.php

    diff --git src/wp-includes/rest-api/endpoints/class-wp-rest-revisions-controller.php src/wp-includes/rest-api/endpoints/class-wp-rest-revisions-controller.php
    index 16aceb0d74..5501c190c1 100644
    class WP_REST_Revisions_Controller extends WP_REST_Controller { 
    2424         */
    2525        private $parent_post_type;
    2626
     27        /**
     28         * Instance of a revision meta fields object.
     29         *
     30         * @since 6.4.0
     31         * @var WP_REST_Post_Meta_Fields
     32         */
     33        protected $meta;
     34
    2735        /**
    2836         * Parent controller.
    2937         *
    class WP_REST_Revisions_Controller extends WP_REST_Controller { 
    6068                $this->rest_base         = 'revisions';
    6169                $this->parent_base       = ! empty( $post_type_object->rest_base ) ? $post_type_object->rest_base : $post_type_object->name;
    6270                $this->namespace         = ! empty( $post_type_object->rest_namespace ) ? $post_type_object->rest_namespace : 'wp/v2';
     71                $this->meta              = new WP_REST_Post_Meta_Fields( $parent_post_type );
    6372        }
    6473
    6574        /**
    class WP_REST_Revisions_Controller extends WP_REST_Controller { 
    619628                        );
    620629                }
    621630
     631                if ( rest_is_field_included( 'meta', $fields ) ) {
     632                        $data['meta'] = $this->meta->get_value( $post->ID, $request );
     633                }
     634
    622635                $context  = ! empty( $request['context'] ) ? $request['context'] : 'view';
    623636                $data     = $this->add_additional_fields_to_object( $data, $request );
    624637                $data     = $this->filter_response_by_context( $data, $context );
    class WP_REST_Revisions_Controller extends WP_REST_Controller { 
    752765                        $schema['properties']['guid'] = $parent_schema['properties']['guid'];
    753766                }
    754767
     768                $schema['properties']['meta'] = $this->meta->get_field_schema();
     769
    755770                $this->schema = $schema;
    756771
    757772                return $this->add_additional_fields_schema( $this->schema );
  • src/wp-includes/revision.php

    diff --git src/wp-includes/revision.php src/wp-includes/revision.php
    index d5a5829d7e..d17c79b1b6 100644
    function _wp_post_revision_data( $post = array(), $autosave = false ) { 
    9595        return $revision_data;
    9696}
    9797
     98/**
     99 * Saves revisions for a post after all changes have been made.
     100 *
     101 * @since 6.4.0
     102 *
     103 * @param int     $post_id The post id that was inserted.
     104 * @param WP_Post $post    The post object that was inserted.
     105 * @param bool    $update  Whether this insert is updating an existing post.
     106 */
     107function wp_save_post_revision_on_insert( $post_id, $post, $update ) {
     108        if ( ! $update ) {
     109                return;
     110        }
     111
     112        if ( ! has_action( 'post_updated', 'wp_save_post_revision' ) ) {
     113                return;
     114        }
     115
     116        wp_save_post_revision( $post_id );
     117}
     118
    98119/**
    99120 * Creates a revision for the current version of a post.
    100121 *
    function wp_save_post_revision( $post_id ) { 
    111132                return;
    112133        }
    113134
     135        // Prevent saving post revisions if revisions should be saved on wp_after_insert_post.
     136        if ( doing_action( 'post_updated' ) && has_action( 'wp_after_insert_post', 'wp_save_post_revision_on_insert' ) ) {
     137                return;
     138        }
     139
    114140        $post = get_post( $post_id );
    115141
    116142        if ( ! $post ) {
    function _wp_put_post_revision( $post = null, $autosave = false ) { 
    361387                 * Fires once a revision has been saved.
    362388                 *
    363389                 * @since 2.6.0
     390                 * @since 6.4.0 The post_id parameter was added.
    364391                 *
    365392                 * @param int $revision_id Post revision ID.
     393                 * @param int $post_id     Post ID.
    366394                 */
    367                 do_action( '_wp_put_post_revision', $revision_id );
     395                do_action( '_wp_put_post_revision', $revision_id, $post['post_parent'] );
    368396        }
    369397
    370398        return $revision_id;
    371399}
    372400
     401
     402/**
     403 * Save the revisioned meta fields.
     404 *
     405 * @since 6.4.0
     406 *
     407 * @param int $revision_id The ID of the revision to save the meta to.
     408 * @param int $post_id     The ID of the post the revision is associated with.
     409 */
     410function wp_save_revisioned_meta_fields( $revision_id, $post_id ) {
     411        $post_type = get_post_type( $post_id );
     412        if ( ! $post_type ) {
     413                return;
     414        }
     415
     416        foreach ( wp_post_revision_meta_keys( $post_type ) as $meta_key ) {
     417                if ( metadata_exists( 'post', $post_id, $meta_key ) ) {
     418                        _wp_copy_post_meta( $post_id, $revision_id, $meta_key );
     419                }
     420        }
     421}
     422
    373423/**
    374424 * Gets a post revision.
    375425 *
    function wp_restore_post_revision( $revision, $fields = null ) { 
    450500        // Update last edit user.
    451501        update_post_meta( $post_id, '_edit_last', get_current_user_id() );
    452502
     503        // Restore any revisioned meta fields.
     504        wp_restore_post_revision_meta( $post_id, $revision['ID'] );
     505
    453506        /**
    454507         * Fires after a post revision has been restored.
    455508         *
    function wp_restore_post_revision( $revision, $fields = null ) { 
    463516        return $post_id;
    464517}
    465518
     519/**
     520 * Restore the revisioned meta values for a post.
     521 *
     522 * @param int $post_id     The ID of the post to restore the meta to.
     523 * @param int $revision_id The ID of the revision to restore the meta from.
     524 *
     525 * @since 6.4.0
     526 */
     527function wp_restore_post_revision_meta( $post_id, $revision_id ) {
     528        $post_type = get_post_type( $post_id );
     529        if ( ! $post_type ) {
     530                return;
     531        }
     532
     533        // Restore revisioned meta fields.
     534        foreach ( wp_post_revision_meta_keys( $post_type ) as $meta_key ) {
     535
     536                // Clear any existing meta.
     537                delete_post_meta( $post_id, $meta_key );
     538
     539                _wp_copy_post_meta( $revision_id, $post_id, $meta_key );
     540        }
     541}
     542
     543/**
     544 * Copy post meta for the given key from one post to another.
     545 *
     546 * @param int    $source_post_id Post ID to copy meta value(s) from.
     547 * @param int    $target_post_id Post ID to copy meta value(s) to.
     548 * @param string $meta_key       Meta key to copy.
     549 *
     550 * @since 6.4.0
     551 */
     552function _wp_copy_post_meta( $source_post_id, $target_post_id, $meta_key ) {
     553
     554        foreach ( get_post_meta( $source_post_id, $meta_key ) as $meta_value ) {
     555                /**
     556                 * We use add_metadata() function vs add_post_meta() here
     557                 * to allow for a revision post target OR regular post.
     558                 */
     559                add_metadata( 'post', $target_post_id, $meta_key, wp_slash( $meta_value ) );
     560        }
     561}
     562
     563/**
     564 * Determine which post meta fields should be revisioned.
     565 *
     566 * @since 6.4.0
     567 *
     568 * @param string $post_type The post type being revisioned.
     569 *
     570 * @return array An array of meta keys to be revisioned.
     571 */
     572function wp_post_revision_meta_keys( $post_type ) {
     573        $registered_meta = array_merge(
     574                get_registered_meta_keys( 'post' ),
     575                get_registered_meta_keys( 'post', $post_type )
     576        );
     577
     578        $wp_revisioned_meta_keys = array();
     579
     580        foreach ( $registered_meta as $name => $args ) {
     581                if ( $args['revisions_enabled'] ) {
     582                        $wp_revisioned_meta_keys[ $name ] = true;
     583                }
     584        }
     585
     586        $wp_revisioned_meta_keys = array_keys( $wp_revisioned_meta_keys );
     587
     588        /**
     589         * Filter the list of post meta keys to be revisioned.
     590         *
     591         * @since 6.4.0
     592         *
     593         * @param array $keys       An array of meta fields to be revisioned.
     594         * @param string $post_type The post type being revisioned.
     595         */
     596        return apply_filters( 'wp_post_revision_meta_keys', $wp_revisioned_meta_keys, $post_type );
     597}
     598
     599/**
     600 * Check whether revisioned post meta fields have changed.
     601 *
     602 * @param bool    $post_has_changed Whether the post has changed.
     603 * @param WP_Post $last_revision    The last revision post object.
     604 * @param WP_Post $post             The post object.
     605 *
     606 * @since 6.4.0
     607 */
     608function wp_check_revisioned_meta_fields_have_changed( $post_has_changed, WP_Post $last_revision, WP_Post $post ) {
     609        foreach ( wp_post_revision_meta_keys( $post->post_type ) as $meta_key ) {
     610                if ( get_post_meta( $post->ID, $meta_key ) !== get_post_meta( $last_revision->ID, $meta_key ) ) {
     611                        $post_has_changed = true;
     612                        break;
     613                }
     614        }
     615        return $post_has_changed;
     616}
     617
    466618/**
    467619 * Deletes a revision.
    468620 *
    function _set_preview( $post ) { 
    728880
    729881        add_filter( 'get_the_terms', '_wp_preview_terms_filter', 10, 3 );
    730882        add_filter( 'get_post_metadata', '_wp_preview_post_thumbnail_filter', 10, 3 );
     883        add_filter( 'get_post_metadata', '_wp_preview_meta_filter', 10, 4 );
    731884
    732885        return $post;
    733886}
    function _wp_upgrade_revisions_of_post( $post, $revisions ) { 
    9461099
    9471100        return true;
    9481101}
     1102
     1103/**
     1104 * Filters preview post meta retrieval to get values from the autosave.
     1105 *
     1106 * Filters revisioned meta keys only.
     1107 *
     1108 * @since 6.4.0
     1109 *
     1110 * @param mixed  $value     Meta value to filter.
     1111 * @param int    $object_id Object ID.
     1112 * @param string $meta_key  Meta key to filter a value for.
     1113 * @param bool   $single    Whether to return a single value. Default false.
     1114 * @return mixed Original meta value if the meta key isn't revisioned, the object doesn't exist,
     1115 *               the post type is a revision or the post ID doesn't match the object ID.
     1116 *               Otherwise, the revisioned meta value is returned for the preview.
     1117 */
     1118function _wp_preview_meta_filter( $value, $object_id, $meta_key, $single ) {
     1119
     1120        $post = get_post();
     1121        if (
     1122                empty( $post ) ||
     1123                $post->ID !== $object_id ||
     1124                ! in_array( $meta_key, wp_post_revision_meta_keys( $post->post_type ), true ) ||
     1125                'revision' === $post->post_type
     1126        ) {
     1127                return $value;
     1128        }
     1129
     1130        $preview = wp_get_post_autosave( $post->ID );
     1131        if ( false === $preview ) {
     1132                return $value;
     1133        }
     1134
     1135        return get_post_meta( $preview->ID, $meta_key, $single );
     1136}
  • tests/phpunit/tests/meta/registerMeta.php

    diff --git tests/phpunit/tests/meta/registerMeta.php tests/phpunit/tests/meta/registerMeta.php
    index 4b08e4d82b..329321dd9b 100644
    class Tests_Meta_Register_Meta extends WP_UnitTestCase { 
    9797                                                'sanitize_callback' => null,
    9898                                                'auth_callback'     => '__return_true',
    9999                                                'show_in_rest'      => false,
     100                                                'revisions_enabled' => false,
    100101                                        ),
    101102                                ),
    102103                        ),
    class Tests_Meta_Register_Meta extends WP_UnitTestCase { 
    121122                                                'sanitize_callback' => null,
    122123                                                'auth_callback'     => '__return_true',
    123124                                                'show_in_rest'      => false,
     125                                                'revisions_enabled' => false,
    124126                                        ),
    125127                                ),
    126128                        ),
    class Tests_Meta_Register_Meta extends WP_UnitTestCase { 
    175177                                                'sanitize_callback' => array( $this, '_new_sanitize_meta_cb' ),
    176178                                                'auth_callback'     => '__return_true',
    177179                                                'show_in_rest'      => false,
     180                                                'revisions_enabled' => false,
    178181                                        ),
    179182                                ),
    180183                        ),
    class Tests_Meta_Register_Meta extends WP_UnitTestCase { 
    342345                                                'sanitize_callback' => null,
    343346                                                'auth_callback'     => '__return_true',
    344347                                                'show_in_rest'      => false,
     348                                                'revisions_enabled' => false,
    345349                                        ),
    346350                                ),
    347351                        ),
    class Tests_Meta_Register_Meta extends WP_UnitTestCase { 
    395399                                                'sanitize_callback' => null,
    396400                                                'auth_callback'     => '__return_true',
    397401                                                'show_in_rest'      => false,
     402                                                'revisions_enabled' => false,
    398403                                        ),
    399404                                ),
    400405                        ),
    class Tests_Meta_Register_Meta extends WP_UnitTestCase { 
    10811086                        array( 'user', 'user' ),
    10821087                );
    10831088        }
     1089
     1090        /**
     1091         * Test that attempting to register meta with revisions_enabled set to true on a
     1092         * post type that does not have revisions enabled fails and throws a `doing_it_wrong` notice.
     1093         *
     1094         * @ticket 20564
     1095         */
     1096        public function test_register_meta_with_revisions_enabled_on_post_type_without_revisions() {
     1097                $this->setExpectedIncorrectUsage( 'register_meta' );
     1098
     1099                // Set up a custom post type with revisions disabled.
     1100                register_post_type(
     1101                        'test_post_type',
     1102                        array(
     1103                                'supports' => array( 'title', 'editor' ),
     1104                        )
     1105                );
     1106
     1107                $meta_key = 'registered_key1';
     1108                $args     = array(
     1109                        'revisions_enabled' => true,
     1110                );
     1111
     1112                $register = register_meta(
     1113                        'test_post_type',
     1114                        $meta_key,
     1115                        $args
     1116                );
     1117
     1118                $this->assertFalse( $register );
     1119        }
    10841120}
  • new file tests/phpunit/tests/post/metaRevisions.php

    diff --git tests/phpunit/tests/post/metaRevisions.php tests/phpunit/tests/post/metaRevisions.php
    new file mode 100644
    index 0000000000..74442b53c8
    - +  
     1<?php
     2
     3/**
     4 *
     5 * Tests for post meta revisioning.
     6 *
     7 * @group post
     8 * @group revision
     9 * @group meta
     10 * @group meta-revisions
     11 */
     12class MetaRevisionTests extends WP_UnitTestCase {
     13
     14        /**
     15         * Callback function to add the revisioned keys.
     16         *
     17         * @param array $keys The array of revisioned keys.
     18         *
     19         * @return array
     20         */
     21        public function add_revisioned_keys( $keys ) {
     22                $keys[] = 'meta_revision_test';
     23                $keys[] = 'meta_multiples_test';
     24                return $keys;
     25        }
     26
     27        /**
     28         * Test the revisions system for storage of meta values with slashes.
     29         *
     30         * @param string $passed   The passed data for testing.
     31         *
     32         * @param string $expected The expected value after storing & retrieving.
     33         *
     34         * @group revision
     35         * @group slashed
     36         * @dataProvider slashed_data_provider
     37         */
     38        public function test_revisions_stores_meta_values_with_slashes( $passed, $expected ) {
     39                // Set up a new post.
     40                $post_id = $this->factory->post->create();
     41
     42                // And update to store an initial revision.
     43                wp_update_post(
     44                        array(
     45                                'post_content' => 'some initial content',
     46                                'ID'           => $post_id,
     47                        )
     48                );
     49                add_filter( 'wp_post_revision_meta_keys', array( $this, 'add_revisioned_keys' ) );
     50
     51                // Store a custom meta value, which is not revisioned by default.
     52                update_post_meta( $post_id, 'meta_revision_test', wp_slash( $passed ) );
     53                $this->assertEquals( $expected, get_post_meta( $post_id, 'meta_revision_test', true ) );
     54
     55                // Update the post, storing a revision.
     56                wp_update_post(
     57                        array(
     58                                'post_content' => 'some more content',
     59                                'ID'           => $post_id,
     60                        )
     61                );
     62
     63                // Overwrite.
     64                update_post_meta( $post_id, 'meta_revision_test', 'original' );
     65                // Update the post, storing a revision.
     66                wp_update_post(
     67                        array(
     68                                'post_content' => 'some more content again',
     69                                'ID'           => $post_id,
     70                        )
     71                );
     72
     73                // Restore the previous revision.
     74                $revisions = (array) wp_get_post_revisions( $post_id );
     75
     76                // Go back to load the previous revision.
     77                array_shift( $revisions );
     78                $last_revision = array_shift( $revisions );
     79
     80                // Restore!
     81                wp_restore_post_revision( $last_revision->ID );
     82
     83                $this->assertEquals( $expected, get_post_meta( $post_id, 'meta_revision_test', true ) );
     84        }
     85
     86        /**
     87         * Provide data for the slashed data tests.
     88         */
     89        public function slashed_data_provider() {
     90                return array(
     91                        array(
     92                                'some\text',
     93                                'some\text',
     94                        ),
     95                        array(
     96                                'test some\ \\extra \\\slashed \\\\text ',
     97                                'test some\ \\extra \\\slashed \\\\text ',
     98                        ),
     99                        array(
     100                                "This \'is\' an example \n of a \"quoted\" string",
     101                                "This \'is\' an example \n of a \"quoted\" string",
     102                        ),
     103                        array(
     104                                'some unslashed text just to test! % & * ( ) #',
     105                                'some unslashed text just to test! % & * ( ) #',
     106                        ),
     107                );
     108        }
     109
     110        /**
     111         * Test the revisions system for storage of meta values.
     112         *
     113         * @group revision
     114         */
     115        public function test_revisions_stores_meta_values() {
     116                /*
     117                 * Set Up.
     118                 */
     119
     120                // Set up a new post.
     121                $post_id          = $this->factory->post->create();
     122                $original_post_id = $post_id;
     123
     124                // And update to store an initial revision.
     125                wp_update_post(
     126                        array(
     127                                'post_content' => 'some initial content',
     128                                'ID'           => $post_id,
     129                        )
     130                );
     131
     132                // One revision so far.
     133                $revisions = wp_get_post_revisions( $post_id );
     134                $this->assertCount( 1, $revisions );
     135
     136                /*
     137                 * First set up a meta value.
     138                 */
     139
     140                // Store a custom meta value, which is not revisioned by default.
     141                update_post_meta( $post_id, 'meta_revision_test', 'original' );
     142
     143                // Update the post, storing a revision.
     144                wp_update_post(
     145                        array(
     146                                'post_content' => 'some more content',
     147                                'ID'           => $post_id,
     148                        )
     149                );
     150
     151                $revisions = wp_get_post_revisions( $post_id );
     152                $this->assertCount( 2, $revisions );
     153
     154                // Next, store some updated meta values for the same key.
     155                update_post_meta( $post_id, 'meta_revision_test', 'update1' );
     156
     157                // Save the post, changing content to force a revision.
     158                wp_update_post(
     159                        array(
     160                                'post_content' => 'some updated content',
     161                                'ID'           => $post_id,
     162                        )
     163                );
     164
     165                $revisions = wp_get_post_revisions( $post_id );
     166                $this->assertCount( 3, $revisions );
     167
     168                /*
     169                 * Now restore the original revision.
     170                 */
     171
     172                // Restore the previous revision.
     173                $revisions = (array) wp_get_post_revisions( $post_id );
     174
     175                // Go back two to load the previous revision.
     176                array_shift( $revisions );
     177                $last_revision = array_shift( $revisions );
     178
     179                // Restore!
     180                wp_restore_post_revision( $last_revision->ID );
     181
     182                wp_update_post( array( 'ID' => $post_id ) );
     183                $revisions = wp_get_post_revisions( $post_id );
     184                $this->assertCount( 4, $revisions );
     185
     186                /*
     187                 * Check the meta values to verify they are NOT revisioned - they are not revisioned by default.
     188                 */
     189
     190                // Custom post meta should NOT be restored, orignal value should not be restored, value still 'update1'.
     191                $this->assertEquals( 'update1', get_post_meta( $post_id, 'meta_revision_test', true ) );
     192
     193                update_post_meta( $post_id, 'meta_revision_test', 'update2' );
     194
     195                /*
     196                 * Test the revisioning of custom meta when enabled by the wp_post_revision_meta_keys filter.
     197                 */
     198
     199                // Add the custom field to be revised via the wp_post_revision_meta_keys filter.
     200                add_filter( 'wp_post_revision_meta_keys', array( $this, 'add_revisioned_keys' ) );
     201
     202                // Save the post, changing content to force a revision.
     203                wp_update_post(
     204                        array(
     205                                'post_content' => 'more updated content',
     206                                'ID'           => $post_id,
     207                        )
     208                );
     209
     210                $revisions = array_values( wp_get_post_revisions( $post_id ) );
     211                $this->assertCount( 5, $revisions );
     212                $this->assertEquals( 'update2', get_post_meta( $revisions[0]->ID, 'meta_revision_test', true ) );
     213
     214                // Store custom meta values, which should now be revisioned.
     215                update_post_meta( $post_id, 'meta_revision_test', 'update3' );
     216
     217                /*
     218                 * Save the post again, custom meta should now be revisioned.
     219                 *
     220                 * Note that a revision is saved even though there is no change
     221                 * in post content, because the revisioned post_meta has changed.
     222                 */
     223                wp_update_post(
     224                        array(
     225                                'ID' => $post_id,
     226                        )
     227                );
     228
     229                // This revision contains the existing post meta ('update3').
     230                $revisions = wp_get_post_revisions( $post_id );
     231                $this->assertCount( 6, $revisions );
     232
     233                // Verify that previous post meta is set.
     234                $this->assertEquals( 'update3', get_post_meta( $post_id, 'meta_revision_test', true ) );
     235
     236                // Restore the previous revision.
     237                $revisions = wp_get_post_revisions( $post_id );
     238
     239                // Go back two to load the previous revision.
     240                array_shift( $revisions );
     241                $last_revision = array_shift( $revisions );
     242                wp_restore_post_revision( $last_revision->ID );
     243
     244                /*
     245                 * Verify that previous post meta is restored.
     246                 */
     247                $this->assertEquals( 'update2', get_post_meta( $post_id, 'meta_revision_test', true ) );
     248
     249                // Try storing a blank meta.
     250                update_post_meta( $post_id, 'meta_revision_test', '' );
     251                wp_update_post(
     252                        array(
     253                                'ID' => $post_id,
     254                        )
     255                );
     256
     257                update_post_meta( $post_id, 'meta_revision_test', 'update 4' );
     258                wp_update_post(
     259                        array(
     260                                'ID' => $post_id,
     261                        )
     262                );
     263
     264                // Restore the previous revision.
     265                $revisions = wp_get_post_revisions( $post_id );
     266                array_shift( $revisions );
     267                $last_revision = array_shift( $revisions );
     268                wp_restore_post_revision( $last_revision->ID );
     269
     270                /*
     271                 * Verify that previous blank post meta is restored.
     272                 */
     273                $this->assertEquals( '', get_post_meta( $post_id, 'meta_revision_test', true ) );
     274
     275                /*
     276                 * Test not tracking a key - remove the key from the revisioned meta.
     277                 */
     278                remove_all_filters( 'wp_post_revision_meta_keys' );
     279
     280                // Meta should no longer be revisioned.
     281                update_post_meta( $post_id, 'meta_revision_test', 'update 5' );
     282                wp_update_post(
     283                        array(
     284                                'ID'           => $post_id,
     285                                'post_content' => 'changed content',
     286                        )
     287                );
     288                update_post_meta( $post_id, 'meta_revision_test', 'update 6' );
     289                wp_update_post(
     290                        array(
     291                                'ID'           => $post_id,
     292                                'post_content' => 'go updated content',
     293                        )
     294                );
     295
     296                // Restore the previous revision.
     297                $revisions = wp_get_post_revisions( $post_id );
     298                array_shift( $revisions );
     299                $last_revision = array_shift( $revisions );
     300                wp_restore_post_revision( $last_revision->ID );
     301
     302                /*
     303                 * Verify that previous post meta is NOT restored.
     304                 */
     305                $this->assertEquals( 'update 6', get_post_meta( $post_id, 'meta_revision_test', true ) );
     306
     307                // Add the custom field to be revised via the wp_post_revision_meta_keys filter.
     308                add_filter( 'wp_post_revision_meta_keys', array( $this, 'add_revisioned_keys' ) );
     309
     310                /*
     311                 * Test the revisioning of multiple meta keys.
     312                 */
     313
     314                // Add three values for meta.
     315                update_post_meta( $post_id, 'meta_revision_test', 'update 7' );
     316                add_post_meta( $post_id, 'meta_revision_test', 'update 7 number 2' );
     317                add_post_meta( $post_id, 'meta_revision_test', 'update 7 number 3' );
     318                wp_update_post( array( 'ID' => $post_id ) );
     319
     320                // Update all three values.
     321                update_post_meta( $post_id, 'meta_revision_test', 'update 8', 'update 7' );
     322                update_post_meta( $post_id, 'meta_revision_test', 'update 8 number 2', 'update 7 number 2' );
     323                update_post_meta( $post_id, 'meta_revision_test', 'update 8 number 3', 'update 7 number 3' );
     324
     325                // Restore the previous revision.
     326                $revisions     = wp_get_post_revisions( $post_id );
     327                $last_revision = array_shift( $revisions );
     328                wp_restore_post_revision( $last_revision->ID );
     329
     330                /*
     331                 * Verify that multiple metas stored correctly.
     332                 */
     333                $this->assertEquals( array( 'update 7', 'update 7 number 2', 'update 7 number 3' ), get_post_meta( $post_id, 'meta_revision_test' ) );
     334
     335                /*
     336                 * Test the revisioning of a multidimensional array.
     337                 */
     338                $test_array = array(
     339                        'a' => array(
     340                                '1',
     341                                '2',
     342                                '3',
     343                        ),
     344                        'b' => 'ok',
     345                        'c' => array(
     346                                'multi' => array(
     347                                        'a',
     348                                        'b',
     349                                        'c',
     350                                ),
     351                                'not'   => 'ok',
     352                        ),
     353                );
     354
     355                // Clear any old value.
     356                delete_post_meta( $post_id, 'meta_revision_test' );
     357
     358                // Set the test meta to the array.
     359                update_post_meta( $post_id, 'meta_revision_test', $test_array );
     360
     361                // Update to save.
     362                wp_update_post( array( 'ID' => $post_id ) );
     363
     364                // Set the test meta blank.
     365                update_post_meta( $post_id, 'meta_revision_test', '' );
     366
     367                // Restore the previous revision.
     368                $revisions     = wp_get_post_revisions( $post_id );
     369                $last_revision = array_shift( $revisions );
     370                wp_restore_post_revision( $last_revision->ID );
     371
     372                /*
     373                 * Verify  multidimensional array stored correctly.
     374                 */
     375                $stored_array = get_post_meta( $post_id, 'meta_revision_test' );
     376                $this->assertEquals( $test_array, $stored_array[0] );
     377                /*
     378
     379                 * Test multiple revisions on the same key.
     380                 */
     381
     382                // Set the test meta to the array.
     383                add_post_meta( $post_id, 'meta_multiples_test', 'test1' );
     384                add_post_meta( $post_id, 'meta_multiples_test', 'test2' );
     385                add_post_meta( $post_id, 'meta_multiples_test', 'test3' );
     386
     387                // Update to save.
     388                wp_update_post( array( 'ID' => $post_id ) );
     389
     390                $stored_array = get_post_meta( $post_id, 'meta_multiples_test' );
     391                $expect       = array( 'test1', 'test2', 'test3' );
     392
     393                $this->assertEquals( $expect, $stored_array );
     394
     395                // Restore the previous revision.
     396                $revisions     = wp_get_post_revisions( $post_id );
     397                $last_revision = array_shift( $revisions );
     398                wp_restore_post_revision( $last_revision->ID );
     399
     400                $stored_array = get_post_meta( $post_id, 'meta_multiples_test' );
     401                $expect       = array( 'test1', 'test2', 'test3' );
     402
     403                $this->assertEquals( $expect, $stored_array );
     404
     405                // Cleanup!
     406                wp_delete_post( $original_post_id );
     407        }
     408
     409        /**
     410         * Verify that only existing meta is revisioned.
     411         */
     412        public function only_existing_meta_is_revisioned() {
     413                add_filter( 'wp_post_revision_meta_keys', array( $this, 'add_revisioned_keys' ) );
     414
     415                // Set up a new post.
     416                $post_id = $this->factory->post->create(
     417                        array(
     418                                'post_content' => 'initial content',
     419                        )
     420                );
     421
     422                // Revision v1.
     423                wp_update_post(
     424                        array(
     425                                'ID'           => $post_id,
     426                                'post_content' => 'updated content v1',
     427                        )
     428                );
     429
     430                $this->assertPostNotHasMetaKey( $post_id, 'foo' );
     431                $this->assertPostNotHasMetaKey( $post_id, 'bar' );
     432
     433                $revisions = wp_get_post_revisions( $post_id );
     434                $revision  = array_shift( $revisions );
     435                $this->assertEmpty( get_metadata( 'post', $revision->ID ) );
     436
     437                // Revision v2.
     438                wp_update_post(
     439                        array(
     440                                'ID'           => $post_id,
     441                                'post_content' => 'updated content v2',
     442                                'meta_input'   => array(
     443                                        'foo' => 'foo v2',
     444                                ),
     445                        )
     446                );
     447
     448                $this->assertPostHasMetaKey( $post_id, 'foo' );
     449                $this->assertPostNotHasMetaKey( $post_id, 'bar' );
     450                $this->assertPostNotHasMetaKey( $post_id, 'meta_revision_test' );
     451
     452                $revisions = wp_get_post_revisions( $post_id );
     453                $revision  = array_shift( $revisions );
     454                $this->assertPostHasMetaKey( $revision->ID, 'foo' );
     455                $this->assertPostNotHasMetaKey( $revision->ID, 'bar' );
     456                $this->assertPostNotHasMetaKey( $revision->ID, 'meta_revision_test' );
     457        }
     458
     459        /**
     460         * Verify that blank strings are revisioned correctly.
     461         */
     462        public function blank_meta_is_revisioned() {
     463
     464                add_filter( 'wp_post_revision_meta_keys', array( $this, 'add_revisioned_keys' ) );
     465
     466                // Set up a new post.
     467                $post_id = $this->factory->post->create(
     468                        array(
     469                                'post_content' => 'initial content',
     470                                'meta_input'   => array(
     471                                        'foo' => 'foo',
     472                                ),
     473                        )
     474                );
     475
     476                // Set the test meta to an empty string.
     477                update_post_meta( $post_id, 'foo', '' );
     478
     479                // Update to save.
     480                wp_update_post( array( 'ID' => $post_id ) );
     481
     482                $stored_array = get_post_meta( $post_id, 'meta_multiples_test' );
     483                $expect       = array( 'test1', 'test2', 'test3' );
     484
     485                $this->assertEquals( $expect, $stored_array );
     486
     487                // Restore the previous revision.
     488                $revisions     = wp_get_post_revisions( $post_id );
     489                $last_revision = array_shift( $revisions );
     490                wp_restore_post_revision( $last_revision->ID );
     491                $stored_data = get_post_meta( $post_id, 'foo' );
     492                $this->assertEquals( '', $stored_data[0] );
     493        }
     494
     495        /**
     496         * Test revisioning of meta with a default value.
     497         */
     498        public function test_revisionining_of_meta_with_default_value() {
     499
     500                // Add a meta field to revision that includes a default value.
     501                register_post_meta(
     502                        'post',
     503                        'meta_revision_test',
     504                        array(
     505                                'single'            => true,
     506                                'default'           => 'default value',
     507                                'revisions_enabled' => true,
     508                        )
     509                );
     510
     511                // Set up a new post.
     512                $post_id = $this->factory->post->create(
     513                        array(
     514                                'post_content' => 'initial content',
     515                                'meta_input'   => array(
     516                                        'meta_revision_test' => 'foo',
     517                                ),
     518                        )
     519                );
     520
     521                // Set the test meta to an empty string.
     522                update_post_meta( $post_id, 'meta_revision_test', '' );
     523
     524                // Update to save.
     525                wp_update_post( array( 'ID' => $post_id ) );
     526
     527                // Check that the meta is blank.
     528                $stored_data = get_post_meta( $post_id, 'meta_revision_test', true );
     529                $this->assertEquals( '', $stored_data );
     530
     531                // Also verify that the latest revision has blank stored for the meta.
     532                $revisions     = wp_get_post_revisions( $post_id );
     533                $last_revision = array_shift( $revisions );
     534                $stored_data   = get_post_meta( $last_revision->ID, 'meta_revision_test', true );
     535                $this->assertEquals( '', $stored_data );
     536
     537                // Delete the meta.
     538                delete_post_meta( $post_id, 'meta_revision_test' );
     539
     540                // Update to save.
     541                wp_update_post(
     542                        array(
     543                                'ID'           => $post_id,
     544                                'post_content' => 'content update 1',
     545                        )
     546                );
     547
     548                // Check that the default meta value is returned.
     549                $this->assertEquals( 'default value', get_post_meta( $post_id, 'meta_revision_test', true ) );
     550
     551                // Also verify that the latest revision has the default value returned for the meta.
     552                $revisions     = wp_get_post_revisions( $post_id );
     553                $last_revision = array_shift( $revisions );
     554
     555                // No ,eta data should be stored in the revision.
     556                $this->assertEquals( array(), get_post_meta( $last_revision->ID ) );
     557
     558                // Set the test meta again.
     559                update_post_meta( $post_id, 'meta_revision_test', 'test' );
     560
     561                // Update to save.
     562                wp_update_post( array( 'ID' => $post_id ) );
     563
     564                // Now restore the previous revision.
     565                wp_restore_post_revision( $last_revision->ID );
     566
     567                // Verify the default meta value is still returned.
     568                $this->assertEquals( 'default value', get_post_meta( $post_id, 'meta_revision_test', true ) );
     569        }
     570
     571        /**
     572         * @dataProvider data_register_post_meta_supports_revisions
     573         */
     574        public function test_register_post_meta_supports_revisions( $post_type, $meta_key, $args, $expected_is_revisioned ) {
     575                register_post_meta( $post_type, $meta_key, $args );
     576
     577                // Set up a new post.
     578                $post_id = $this->factory->post->create(
     579                        array(
     580                                'post_content' => 'initial content',
     581                                'post_type'    => $post_type,
     582                                'meta_input'   => array(
     583                                        $meta_key => 'foo',
     584                                ),
     585                        )
     586                );
     587
     588                // Update the post meta and post to save.
     589                update_post_meta( $post_id, $meta_key, 'bar' );
     590                wp_update_post(
     591                        array(
     592                                'ID'         => $post_id,
     593                                'post_title' => 'updated title',
     594                        )
     595                );
     596
     597                // Check the last revision for the post to see if the meta key was revisioned
     598                $revisions       = wp_get_post_revisions( $post_id );
     599                $revision        = array_shift( $revisions );
     600                $revisioned_meta = get_post_meta( $revision->ID, $meta_key, true );
     601                $this->assertEquals( $expected_is_revisioned, 'bar' === $revisioned_meta );
     602
     603                // Reset global so subsequent data tests do not get polluted.
     604                $GLOBALS['wp_meta_keys'] = array();
     605        }
     606
     607        public function data_register_post_meta_supports_revisions() {
     608                return array(
     609                        array( 'post', 'registered_key1', array( 'single' => true ), false ),
     610                        array(
     611                                'post',
     612                                'registered_key1',
     613                                array(
     614                                        'single'            => true,
     615                                        'revisions_enabled' => true,
     616                                ),
     617                                true,
     618                        ),
     619                        array( 'page', 'registered_key2', array( 'revisions_enabled' => false ), false ),
     620                        array( 'page', 'registered_key2', array( 'revisions_enabled' => true ), true ),
     621                        array( '', 'registered_key3', array( 'revisions_enabled' => false ), false ),
     622                        array( '', 'registered_key3', array( 'revisions_enabled' => true ), true ),
     623                );
     624        }
     625
     626        /**
     627         * Assert the a post has a meta key.
     628         *
     629         * @param int    $post_id        The ID of the post to check.
     630         * @param string $meta_key The meta key to check for.
     631         */
     632        protected function assertPostHasMetaKey( $post_id, $meta_key ) {
     633                $this->assertArrayHasKey( $meta_key, get_metadata( 'post', $post_id ) );
     634        }
     635
     636        /**
     637         * Assert that post does not have a meta key.
     638         *
     639         * @param int    $post_id        The ID of the post to check.
     640         * @param string $meta_key The meta key to check for.
     641         */
     642        protected function assertPostNotHasMetaKey( $post_id, $meta_key ) {
     643                $this->assertArrayNotHasKey( $meta_key, get_metadata( 'post', $post_id ) );
     644        }
     645
     646        /**
     647         * Test post meta revisioning with a custom post type, as well as the "page" post type.
     648         *
     649         * @dataProvider page_post_type_data_provider
     650         */
     651        public function test_revisions_stores_meta_values_page_and_cpt( $passed, $expected, $post_type, $supports_revisions = false ) {
     652
     653                // If the post type doesn't exist, create it, potentially supporting revisions.
     654                if ( ! post_type_exists( $post_type ) ) {
     655                        register_post_type(
     656                                $post_type,
     657                                array(
     658                                        'public'   => true,
     659                                        'supports' => $supports_revisions ? array( 'revisions' ) : array(),
     660                                )
     661                        );
     662                }
     663
     664                // Create a test post.
     665                $page_id = $this->factory->post->create(
     666                        array(
     667                                'post_type'    => $post_type,
     668                                'post_content' => 'some initial content',
     669                        )
     670                );
     671
     672                // Add the revisioning filter.
     673                add_filter( 'wp_post_revision_meta_keys', array( $this, 'add_revisioned_keys' ) );
     674
     675                // Test revisioning.
     676                update_post_meta( $page_id, 'meta_revision_test', wp_slash( $passed ) );
     677
     678                // Update the post, storing a revision.
     679                wp_update_post(
     680                        array(
     681                                'post_content' => 'some more content',
     682                                'ID'           => $page_id,
     683                        )
     684                );
     685
     686                // Retrieve the created revision.
     687                $revisions = (array) wp_get_post_revisions( $page_id );
     688
     689                if ( $expected ) {
     690                        // Go back to load the previous revision.
     691                        $last_revision = array_shift( $revisions );
     692                                wp_restore_post_revision( $last_revision->ID );
     693                        $this->assertEquals( $expected, get_post_meta( $page_id, 'meta_revision_test', true ) );
     694                } else {
     695                        $this->assertEmpty( $revisions );
     696                }
     697        }
     698
     699        /**
     700         * Provide data for the page post type tests.
     701         */
     702        public function page_post_type_data_provider() {
     703                return array(
     704                        array(
     705                                'Test string',
     706                                'Test string',
     707                                'page',
     708                        ),
     709                        array(
     710                                'Test string',
     711                                false,
     712                                'custom_type',
     713                        ),
     714                        array(
     715                                'Test string',
     716                                'Test string',
     717                                'custom_type',
     718                                true,
     719                        ),
     720                );
     721        }
     722}
  • tests/phpunit/tests/rest-api/rest-autosaves-controller.php

    diff --git tests/phpunit/tests/rest-api/rest-autosaves-controller.php tests/phpunit/tests/rest-api/rest-autosaves-controller.php
    index fd8f92f7b0..4108d05efc 100644
    class WP_Test_REST_Autosaves_Controller extends WP_Test_REST_Post_Type_Controlle 
    215215                        'author',
    216216                        'date',
    217217                        'date_gmt',
     218                        'id',
     219                        'meta',
    218220                        'modified',
    219221                        'modified_gmt',
    220                         'guid',
    221                         'id',
    222222                        'parent',
    223223                        'slug',
     224                        'guid',
    224225                        'title',
    225226                        'excerpt',
    226227                        'content',
    class WP_Test_REST_Autosaves_Controller extends WP_Test_REST_Post_Type_Controlle 
    288289                $response   = rest_get_server()->dispatch( $request );
    289290                $data       = $response->get_data();
    290291                $properties = $data['schema']['properties'];
    291                 $this->assertCount( 13, $properties );
     292                $this->assertCount( 14, $properties );
    292293                $this->assertArrayHasKey( 'author', $properties );
    293294                $this->assertArrayHasKey( 'content', $properties );
    294295                $this->assertArrayHasKey( 'date', $properties );
    class WP_Test_REST_Autosaves_Controller extends WP_Test_REST_Post_Type_Controlle 
    302303                $this->assertArrayHasKey( 'slug', $properties );
    303304                $this->assertArrayHasKey( 'title', $properties );
    304305                $this->assertArrayHasKey( 'preview_link', $properties );
     306                $this->assertArrayHasKey( 'meta', $properties );
    305307        }
    306308
    307309        public function test_create_item() {
  • tests/phpunit/tests/rest-api/rest-global-styles-revisions-controller.php

    diff --git tests/phpunit/tests/rest-api/rest-global-styles-revisions-controller.php tests/phpunit/tests/rest-api/rest-global-styles-revisions-controller.php
    index 9e580d5f3c..30e5b983ea 100644
    class WP_REST_Global_Styles_Revisions_Controller_Test extends WP_Test_REST_Contr 
    132132                        ),
    133133                );
    134134
    135                 wp_update_post( $new_styles_post, true, false );
     135                wp_update_post( $new_styles_post, true );
    136136
    137137                $new_styles_post = array(
    138138                        'ID'           => self::$global_styles_id,
    class WP_REST_Global_Styles_Revisions_Controller_Test extends WP_Test_REST_Contr 
    162162                        ),
    163163                );
    164164
    165                 wp_update_post( $new_styles_post, true, false );
     165                wp_update_post( $new_styles_post, true );
    166166
    167167                $new_styles_post = array(
    168168                        'ID'           => self::$global_styles_id,
    class WP_REST_Global_Styles_Revisions_Controller_Test extends WP_Test_REST_Contr 
    192192                        ),
    193193                );
    194194
    195                 wp_update_post( $new_styles_post, true, false );
     195                wp_update_post( $new_styles_post, true );
    196196                wp_set_current_user( 0 );
    197197        }
    198198
    class WP_REST_Global_Styles_Revisions_Controller_Test extends WP_Test_REST_Contr 
    326326                        'post_content' => wp_json_encode( $config ),
    327327                );
    328328
    329                 wp_update_post( $updated_styles_post, true, false );
     329                wp_update_post( $updated_styles_post, true );
    330330
    331331                $request  = new WP_REST_Request( 'GET', '/wp/v2/global-styles/' . self::$global_styles_id . '/revisions' );
    332332                $response = rest_get_server()->dispatch( $request );
  • tests/phpunit/tests/rest-api/rest-post-meta-fields.php

    diff --git tests/phpunit/tests/rest-api/rest-post-meta-fields.php tests/phpunit/tests/rest-api/rest-post-meta-fields.php
    index 11d06b86be..c164c406b0 100644
    class WP_Test_REST_Post_Meta_Fields extends WP_Test_REST_TestCase { 
    1717                        'cpt',
    1818                        array(
    1919                                'show_in_rest' => true,
    20                                 'supports'     => array( 'custom-fields' ),
     20                                'supports'     => array( 'custom-fields', 'revisions' ),
    2121                        )
    2222                );
    2323
    class WP_Test_REST_Post_Meta_Fields extends WP_Test_REST_TestCase { 
    157157                        'cpt',
    158158                        array(
    159159                                'show_in_rest' => true,
    160                                 'supports'     => array( 'custom-fields' ),
     160                                'supports'     => array( 'custom-fields', 'revisions' ),
    161161                        )
    162162                );
    163163
    class WP_Test_REST_Post_Meta_Fields extends WP_Test_REST_TestCase { 
    13761376         * @dataProvider data_update_value_return_success_with_same_value
    13771377         */
    13781378        public function test_update_value_return_success_with_same_value( $meta_key, $meta_value ) {
    1379                 add_post_meta( self::$post_id, $meta_key, $meta_value );
    1380 
    13811379                $this->grant_write_permission();
    13821380
    13831381                $data = array(
    class WP_Test_REST_Post_Meta_Fields extends WP_Test_REST_TestCase { 
    13921390                $response = rest_get_server()->dispatch( $request );
    13931391
    13941392                $this->assertSame( 200, $response->get_status() );
     1393
     1394                // Verify the returned meta value is correct.
     1395                $data = $response->get_data();
     1396                $this->assertArrayHasKey( 'meta', $data );
     1397                $this->assertArrayHasKey( $meta_key, $data['meta'] );
     1398                $this->assertSame( $meta_value, $data['meta'][ $meta_key ] );
    13951399        }
    13961400
    13971401        public function data_update_value_return_success_with_same_value() {
    class WP_Test_REST_Post_Meta_Fields extends WP_Test_REST_TestCase { 
    31123116                }
    31133117                return $query;
    31143118        }
     3119
     3120
     3121        /**
     3122         * Test that single post meta is revisioned when saving to the posts REST API endpoint.
     3123         *
     3124         * @ticket 20564
     3125         */
     3126        public function test_revisioned_single_post_meta_with_posts_endpoint() {
     3127                $this->grant_write_permission();
     3128
     3129                register_post_meta(
     3130                        'post',
     3131                        'foo',
     3132                        array(
     3133                                'single'            => true,
     3134                                'show_in_rest'      => true,
     3135                                'revisions_enabled' => true,
     3136                        )
     3137                );
     3138
     3139                $post_id = self::$post_id;
     3140
     3141                // Update the post, saving the meta.
     3142                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3143                $request->set_body_params(
     3144                        array(
     3145                                'title' => 'Revision 1',
     3146                                'meta'  => array(
     3147                                        'foo' => 'bar',
     3148                                ),
     3149                        )
     3150                );
     3151                $response = rest_get_server()->dispatch( $request );
     3152                $this->assertSame( 200, $response->get_status() );
     3153
     3154                // Get the last revision.
     3155                $revisions   = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3156                $revision_id = array_shift( $revisions )->ID;
     3157
     3158                // @todo Ensure the revisions endpoint returns the correct meta values
     3159                // Check that the revisions endpoint returns the correct meta value.
     3160                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/posts/%d/revisions/%d', $post_id, $revision_id ) );
     3161                $response = rest_get_server()->dispatch( $request );
     3162                $this->assertSame( 200, $response->get_status() );
     3163                $data = $response->get_data();
     3164                $this->assertSame( 'bar', $response->get_data()['meta']['foo'] );
     3165
     3166                // Check that the post meta is set correctly.
     3167                $this->assertSame( 'bar', get_post_meta( $revision_id, 'foo', true ) );
     3168
     3169                // Create two more revisions with different meta values for the foo key.
     3170                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3171                $request->set_body_params(
     3172                        array(
     3173                                'title' => 'Revision 2',
     3174                                'meta'  => array(
     3175                                        'foo' => 'baz',
     3176                                ),
     3177                        )
     3178                );
     3179                $response = rest_get_server()->dispatch( $request );
     3180                $this->assertSame( 200, $response->get_status() );
     3181
     3182                // Get the last revision.
     3183                $revisions     = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3184                $revision_id_2 = array_shift( $revisions )->ID;
     3185
     3186                // Check that the revision has the correct meta value.
     3187                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/posts/%d/revisions/%d', $post_id, $revision_id_2 ) );
     3188                $response = rest_get_server()->dispatch( $request );
     3189                $this->assertSame( 200, $response->get_status() );
     3190                $this->assertSame( 'baz', $response->get_data()['meta']['foo'] );
     3191
     3192                // Check that the post meta is set correctly.
     3193                $this->assertSame( 'baz', get_post_meta( $revision_id_2, 'foo', true ) );
     3194
     3195                // One more revision!
     3196                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3197                $request->set_body_params(
     3198                        array(
     3199                                'title' => 'Revision 3',
     3200                                'meta'  => array(
     3201                                        'foo' => 'qux',
     3202                                ),
     3203                        )
     3204                );
     3205                $response = rest_get_server()->dispatch( $request );
     3206                $this->assertSame( 200, $response->get_status() );
     3207
     3208                // Get the last revision.
     3209                $revisions     = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3210                $revision_id_3 = array_shift( $revisions )->ID;
     3211
     3212                // Check that the revision has the correct meta value.
     3213                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/posts/%d/revisions/%d', $post_id, $revision_id_3 ) );
     3214                $response = rest_get_server()->dispatch( $request );
     3215                $this->assertSame( 200, $response->get_status() );
     3216                $this->assertSame( 'qux', $response->get_data()['meta']['foo'] );
     3217
     3218                // Check that the post meta is set correctly.
     3219                $this->assertSame( 'qux', get_post_meta( $revision_id_3, 'foo', true ) );
     3220
     3221                // Restore Revision 3 and verify the post gets the correct meta value.
     3222                wp_restore_post_revision( $revision_id_3 );
     3223                $this->assertSame( 'qux', get_post_meta( $post_id, 'foo', true ) );
     3224
     3225                // Restore Revision 2 and verify the post gets the correct meta value.
     3226                wp_restore_post_revision( $revision_id_2 );
     3227                $this->assertSame( 'baz', get_post_meta( $post_id, 'foo', true ) );
     3228        }
     3229
     3230        /**
     3231         * Test that multi-post meta is revisioned when saving to the posts REST API endpoint.
     3232         *
     3233         * @ticket 20564
     3234         */
     3235        public function test_revisioned_multiple_post_meta_with_posts_endpoint() {
     3236                $this->grant_write_permission();
     3237
     3238                register_post_meta(
     3239                        'post',
     3240                        'foo',
     3241                        array(
     3242                                'single'            => false,
     3243                                'show_in_rest'      => true,
     3244                                'revisions_enabled' => true,
     3245                        )
     3246                );
     3247
     3248                $post_id = self::$post_id;
     3249
     3250                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3251                $request->set_body_params(
     3252                        array(
     3253                                'title' => 'Revision 1',
     3254                                'meta'  => array(
     3255                                        'foo' => array(
     3256                                                'bar',
     3257                                                'bat',
     3258                                                'baz',
     3259                                        ),
     3260                                ),
     3261                        )
     3262                );
     3263                $response = rest_get_server()->dispatch( $request );
     3264                $this->assertSame( 200, $response->get_status() );
     3265
     3266                // Log the current post meta.
     3267                $meta = get_post_meta( $post_id );
     3268
     3269                // Update the post.
     3270                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3271                $request->set_body_params(
     3272                        array(
     3273                                'title' => 'Revision 1 update',
     3274                        )
     3275                );
     3276                $response = rest_get_server()->dispatch( $request );
     3277                $this->assertSame( 200, $response->get_status() );
     3278
     3279                // Get the last revision.
     3280                $revisions     = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3281                $revision_id_1 = array_shift( $revisions )->ID;
     3282
     3283                // Check that the revision has the correct meta value.
     3284                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/posts/%d/revisions/%d', $post_id, $revision_id_1 ) );
     3285                $response = rest_get_server()->dispatch( $request );
     3286                $this->assertSame( 200, $response->get_status() );
     3287
     3288                $this->assertSame(
     3289                        array( 'bar', 'bat', 'baz' ),
     3290                        $response->get_data()['meta']['foo']
     3291                );
     3292                $this->assertSame(
     3293                        array( 'bar', 'bat', 'baz' ),
     3294                        get_post_meta( $revision_id_1, 'foo' )
     3295                );
     3296
     3297                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3298                $request->set_body_params(
     3299                        array(
     3300                                'title' => 'Revision 2',
     3301                                'meta'  => array(
     3302                                        'foo' => array(
     3303                                                'car',
     3304                                                'cat',
     3305                                        ),
     3306                                ),
     3307                        )
     3308                );
     3309                $response = rest_get_server()->dispatch( $request );
     3310                $this->assertSame( 200, $response->get_status() );
     3311
     3312                // Get the last revision.
     3313                $revisions     = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3314                $revision_id_2 = array_shift( $revisions )->ID;
     3315
     3316                // Check that the revision has the correct meta value.
     3317                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/posts/%d/revisions/%d', $post_id, $revision_id_2 ) );
     3318                $response = rest_get_server()->dispatch( $request );
     3319                $this->assertSame( 200, $response->get_status() );
     3320
     3321                $this->assertSame(
     3322                        array( 'car', 'cat' ),
     3323                        $response->get_data()['meta']['foo']
     3324                );
     3325                $this->assertSame( array( 'car', 'cat' ), get_post_meta( $revision_id_2, 'foo' ) );
     3326
     3327                $request = new WP_REST_Request( 'PUT', sprintf( '/wp/v2/posts/%d', $post_id ) );
     3328                $request->set_body_params(
     3329                        array(
     3330                                'title' => 'Revision 3',
     3331                                'meta'  => array(
     3332                                        'foo' => null,
     3333                                ),
     3334                        )
     3335                );
     3336                $response = rest_get_server()->dispatch( $request );
     3337                $this->assertSame( 200, $response->get_status() );
     3338
     3339                // Get the last revision.
     3340                $revisions     = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3341                $revision_id_3 = array_shift( $revisions )->ID;
     3342
     3343                // Check that the revision has the correct meta value.
     3344                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/posts/%d/revisions/%d', $post_id, $revision_id_3 ) );
     3345                $response = rest_get_server()->dispatch( $request );
     3346                $this->assertSame( 200, $response->get_status() );
     3347
     3348                $this->assertSame(
     3349                        array(),
     3350                        $response->get_data()['meta']['foo']
     3351                );
     3352                $this->assertSame( array(), get_post_meta( $revision_id_3, 'foo' ) );
     3353
     3354                // Restore Revision 3 and verify the post gets the correct meta value.
     3355                wp_restore_post_revision( $revision_id_3 );
     3356                $this->assertSame( array(), get_post_meta( $post_id, 'foo' ) );
     3357
     3358                // Restore Revision 2 and verify the post gets the correct meta value.
     3359                wp_restore_post_revision( $revision_id_2 );
     3360                $this->assertSame( array( 'car', 'cat' ), get_post_meta( $post_id, 'foo' ) );
     3361        }
     3362
     3363        /**
     3364         * Test post meta revisions with a custom post type and the page post type.
     3365         *
     3366         * @group revision
     3367         * @dataProvider test_revisioned_single_post_meta_with_posts_endpoint_page_and_cpt_data_provider
     3368         */
     3369        public function test_revisioned_single_post_meta_with_posts_endpoint_page_and_cpt( $passed, $expected, $post_type ) {
     3370
     3371                $this->grant_write_permission();
     3372
     3373                // Create the custom meta.
     3374                register_post_meta(
     3375                        $post_type,
     3376                        'foo',
     3377                        array(
     3378                                'show_in_rest'      => true,
     3379                                'revisions_enabled' => true,
     3380                                'single'            => true,
     3381                                'type'              => 'string',
     3382                        )
     3383                );
     3384
     3385                // Set up a new post.
     3386                $post_id = $this->factory->post->create(
     3387                        array(
     3388                                'post_content' => 'initial content',
     3389                                'post_type'    => $post_type,
     3390                                'meta_input'   => array(
     3391                                        'foo' => 'foo',
     3392                                ),
     3393                        )
     3394                );
     3395
     3396                $plural_mapping = array(
     3397                        'page' => 'pages',
     3398                        'cpt'  => 'cpt',
     3399                );
     3400                $request        = new WP_REST_Request( 'GET', sprintf( '/wp/v2/%s', $plural_mapping[ $post_type ] ) );
     3401
     3402                $response = rest_get_server()->dispatch( $request );
     3403
     3404                $request = new WP_REST_Request( 'POST', sprintf( '/wp/v2/%s/%d', $plural_mapping[ $post_type ], $post_id ) );
     3405                $request->set_body_params(
     3406                        array(
     3407                                'title' => 'Revision 1',
     3408                                'meta'  => array(
     3409                                        'foo' => $passed,
     3410                                ),
     3411                        )
     3412                );
     3413
     3414                $response = rest_get_server()->dispatch( $request );
     3415                $this->assertSame( 200, $response->get_status() );
     3416
     3417                // Update the post.
     3418                $request = new WP_REST_Request( 'POST', sprintf( '/wp/v2/%s/%d', $plural_mapping[ $post_type ], $post_id ) );
     3419                $request->set_body_params(
     3420                        array(
     3421                                'title' => 'Revision 1 update',
     3422                        )
     3423                );
     3424                $response = rest_get_server()->dispatch( $request );
     3425                $this->assertSame( 200, $response->get_status() );
     3426
     3427                // Get the last revision.
     3428                $revisions = wp_get_post_revisions( $post_id, array( 'posts_per_page' => 1 ) );
     3429
     3430                $revision_id_1 = array_shift( $revisions )->ID;
     3431
     3432                // Check that the revision has the correct meta value.
     3433                $request  = new WP_REST_Request( 'GET', sprintf( '/wp/v2/%s/%d/revisions/%d', $plural_mapping[ $post_type ], $post_id, $revision_id_1 ) );
     3434                $response = rest_get_server()->dispatch( $request );
     3435                $this->assertSame( 200, $response->get_status() );
     3436
     3437                $this->assertSame(
     3438                        $passed,
     3439                        $response->get_data()['meta']['foo']
     3440                );
     3441
     3442                $this->assertSame(
     3443                        array( $passed ),
     3444                        get_post_meta( $revision_id_1, 'foo' )
     3445                );
     3446
     3447                unregister_post_meta( $post_type, 'foo' );
     3448                wp_delete_post( $post_id, true );
     3449        }
     3450
     3451        /**
     3452         * Provide data for the meta revision checks.
     3453         */
     3454        public function test_revisioned_single_post_meta_with_posts_endpoint_page_and_cpt_data_provider() {
     3455                return array(
     3456                        array(
     3457                                'Test string',
     3458                                'Test string',
     3459                                'cpt',
     3460                        ),
     3461                        array(
     3462                                'Test string',
     3463                                'Test string',
     3464                                'page',
     3465                        ),
     3466                        array(
     3467                                'Test string',
     3468                                false,
     3469                                'cpt',
     3470                        ),
     3471
     3472                );
     3473        }
    31153474}
  • tests/phpunit/tests/rest-api/rest-revisions-controller.php

    diff --git tests/phpunit/tests/rest-api/rest-revisions-controller.php tests/phpunit/tests/rest-api/rest-revisions-controller.php
    index e0b713c882..74cd040d85 100644
    class WP_Test_REST_Revisions_Controller extends WP_Test_REST_Controller_Testcase 
    179179                        'modified_gmt',
    180180                        'guid',
    181181                        'id',
     182                        'meta',
    182183                        'parent',
    183184                        'slug',
    184185                        'title',
    class WP_Test_REST_Revisions_Controller extends WP_Test_REST_Controller_Testcase 
    335336                $response   = rest_get_server()->dispatch( $request );
    336337                $data       = $response->get_data();
    337338                $properties = $data['schema']['properties'];
    338                 $this->assertCount( 12, $properties );
     339                $this->assertCount( 13, $properties );
    339340                $this->assertArrayHasKey( 'author', $properties );
    340341                $this->assertArrayHasKey( 'content', $properties );
    341342                $this->assertArrayHasKey( 'date', $properties );
    class WP_Test_REST_Revisions_Controller extends WP_Test_REST_Controller_Testcase 
    348349                $this->assertArrayHasKey( 'parent', $properties );
    349350                $this->assertArrayHasKey( 'slug', $properties );
    350351                $this->assertArrayHasKey( 'title', $properties );
     352                $this->assertArrayHasKey( 'meta', $properties );
    351353        }
    352354
    353355        public function test_create_item() {
  • tests/phpunit/tests/user/wpRegisterPersistedPreferencesMeta.php

    diff --git tests/phpunit/tests/user/wpRegisterPersistedPreferencesMeta.php tests/phpunit/tests/user/wpRegisterPersistedPreferencesMeta.php
    index 9c4725ffbf..8af6ae9b81 100644
    class Tests_User_WpRegisterPersistedPreferencesMeta extends WP_UnitTestCase { 
    5252                                                'additionalProperties' => true,
    5353                                        ),
    5454                                ),
     55                                'revisions_enabled' => false,
    5556                        ),
    5657                        $wp_meta_keys['user'][''][ $meta_key ],
    5758                        'The registered metadata did not have the expected structure'
  • tests/qunit/fixtures/wp-api-generated.js

    diff --git tests/qunit/fixtures/wp-api-generated.js tests/qunit/fixtures/wp-api-generated.js
    index 36cab80cc1..8341830452 100644
    mockedApiResponse.postRevisions = [ 
    1178211782        "excerpt": {
    1178311783            "rendered": ""
    1178411784        },
     11785        "meta": {
     11786            "meta_key": ""
     11787        },
    1178511788        "_links": {
    1178611789            "parent": [
    1178711790                {
    mockedApiResponse.postRevisions = [ 
    1181111814        "excerpt": {
    1181211815            "rendered": "<p>REST API Client Fixture: Post</p>\n"
    1181311816        },
     11817        "meta": {
     11818            "meta_key": ""
     11819        },
    1181411820        "_links": {
    1181511821            "parent": [
    1181611822                {
    mockedApiResponse.revision = { 
    1184111847    },
    1184211848    "excerpt": {
    1184311849        "rendered": "<p>REST API Client Fixture: Post</p>\n"
     11850    },
     11851    "meta": {
     11852        "meta_key": ""
    1184411853    }
    1184511854};
    1184611855
    mockedApiResponse.postAutosaves = [ 
    1186611875        "excerpt": {
    1186711876            "rendered": ""
    1186811877        },
     11878        "meta": {
     11879            "meta_key": ""
     11880        },
    1186911881        "_links": {
    1187011882            "parent": [
    1187111883                {
    mockedApiResponse.autosave = { 
    1189611908    },
    1189711909    "excerpt": {
    1189811910        "rendered": ""
     11911    },
     11912    "meta": {
     11913        "meta_key": ""
    1189911914    }
    1190011915};
    1190111916
    mockedApiResponse.pageRevisions = [ 
    1204212057        "excerpt": {
    1204312058            "rendered": ""
    1204412059        },
     12060        "meta": {
     12061            "meta_key": ""
     12062        },
    1204512063        "_links": {
    1204612064            "parent": [
    1204712065                {
    mockedApiResponse.pageRevisions = [ 
    1207112089        "excerpt": {
    1207212090            "rendered": "<p>REST API Client Fixture: Page</p>\n"
    1207312091        },
     12092        "meta": {
     12093            "meta_key": ""
     12094        },
    1207412095        "_links": {
    1207512096            "parent": [
    1207612097                {
    mockedApiResponse.pageRevision = { 
    1210112122    },
    1210212123    "excerpt": {
    1210312124        "rendered": "<p>REST API Client Fixture: Page</p>\n"
     12125    },
     12126    "meta": {
     12127        "meta_key": ""
    1210412128    }
    1210512129};
    1210612130
    mockedApiResponse.pageAutosaves = [ 
    1212612150        "excerpt": {
    1212712151            "rendered": ""
    1212812152        },
     12153        "meta": {
     12154            "meta_key": ""
     12155        },
    1212912156        "_links": {
    1213012157            "parent": [
    1213112158                {
    mockedApiResponse.pageAutosave = { 
    1215612183    },
    1215712184    "excerpt": {
    1215812185        "rendered": ""
     12186    },
     12187    "meta": {
     12188        "meta_key": ""
    1215912189    }
    1216012190};
    1216112191