WordPress.org

Make WordPress Core

Ticket #44707: 44707.2.diff

File 44707.2.diff, 9.7 KB (added by desrosj, 19 months ago)
  • src/wp-includes/user.php

     
    33303330                        'post_type'     => 'user_request',
    33313331                        'post_name__in' => array( $action_name ),  // Action name stored in post_name column.
    33323332                        'title'         => $email_address, // Email address stored in post_title column.
    3333                         'post_status'   => 'any',
     3333                        'post_status'   => array(
     3334                                'request-pending',
     3335                                'request-confirmed',
     3336                        ),
    33343337                        'fields'        => 'ids',
    33353338                )
    33363339        );
    33373340
    33383341        if ( $requests_query->found_posts ) {
    3339                 return new WP_Error( 'duplicate_request', __( 'A request for this email address already exists.' ) );
     3342                return new WP_Error( 'duplicate_request', __( 'An incomplete request for this email address already exists.' ) );
    33403343        }
    33413344
    33423345        $request_id = wp_insert_post(
  • tests/phpunit/tests/privacy/wpCreateUserRequest.php

     
     1<?php
     2/**
     3 * Test the `wp_create_user_request()` function.
     4 *
     5 * @package WordPress
     6 * @subpackage UnitTests
     7 * @since 5.2.0
     8 */
     9
     10/**
     11 * Tests_WpCreateUserRequest class.
     12 *
     13 * @group privacy
     14 * @covers ::wp_create_user_request
     15 *
     16 * @since 5.2.0
     17 */
     18class Tests_WpCreateUserRequest extends WP_UnitTestCase {
     19        /**
     20         * Request ID.
     21         *
     22         * @since 5.2.0
     23         *
     24         * @var int $request_id
     25         */
     26        protected static $request_id;
     27
     28        /**
     29         * Request email for a registered user.
     30         *
     31         * @since 5.2.0
     32         *
     33         * @var string $registered_user_email
     34         */
     35        protected static $registered_user_email;
     36
     37        /**
     38         * Request email for a non-registered user.
     39         *
     40         * @since 5.2.0
     41         *
     42         * @var string $non_registered_user_email
     43         */
     44        protected static $non_registered_user_email;
     45
     46        /**
     47         * Test user ID.
     48         *
     49         * @since 5.2.0
     50         *
     51         * @var string $user_id
     52         */
     53        protected static $user_id;
     54
     55        /**
     56         * Create fixtures.
     57         *
     58         * @since 5.2.0
     59         *
     60         * @param WP_UnitTest_Factory $factory Factory.
     61         */
     62        public static function wpSetUpBeforeClass( $factory ) {
     63                self::$registered_user_email     = 'export@local.test';
     64                self::$non_registered_user_email = 'non-registered-user@local.test';
     65
     66                self::$user_id = $factory->user->create(
     67                        array(
     68                                'user_email' => self::$registered_user_email,
     69                        )
     70                );
     71
     72                self::$request_id = $factory->post->create(
     73                        array(
     74                                'post_type'   => 'user_request',
     75                                'post_author' => self::$user_id,
     76                                'post_name'   => 'export_personal_data',
     77                                'post_status' => 'request-pending',
     78                                'post_title'  => self::$registered_user_email,
     79                        )
     80                );
     81        }
     82
     83        /**
     84         * Ensure a WP_Error is returned when an invalid email is passed.
     85         *
     86         * @ticket 44707
     87         */
     88        public function test_invalid_email() {
     89                $actual = wp_create_user_request( 'not-a-valid-email', 'export_personal_data' );
     90
     91                $this->assertWPError( $actual );
     92                $this->assertSame( 'invalid_email', $actual->get_error_code() );
     93        }
     94
     95        /**
     96         * Ensure a WP_Error is returned when an invalid action is passed.
     97         *
     98         * @ticket 44707
     99         */
     100        public function test_invalid_action() {
     101                $actual = wp_create_user_request( self::$registered_user_email, false );
     102
     103                $this->assertWPError( $actual );
     104                $this->assertSame( 'invalid_action', $actual->get_error_code() );
     105        }
     106
     107        /**
     108         * When there are incomplete requests for a registered user, a WP_Error should be returned.
     109         *
     110         * @ticket 44707
     111         */
     112        public function test_failure_due_to_incomplete_registered_user() {
     113                // Second request (duplicated).
     114                $actual = wp_create_user_request( self::$registered_user_email, 'export_personal_data' );
     115
     116                $this->assertWPError( $actual );
     117                $this->assertSame( 'duplicate_request', $actual->get_error_code() );
     118        }
     119
     120        /**
     121         * When there are incomplete requests for an non-registered user, a WP_Error should be returned.
     122         *
     123         * @ticket 44707
     124         */
     125        public function test_failure_due_to_incomplete_unregistered_user() {
     126                // Update first request.
     127                wp_update_post(
     128                        array(
     129                                'ID'          => self::$request_id,
     130                                'post_author' => 0,
     131                                'post_title'  => self::$non_registered_user_email,
     132                        )
     133                );
     134
     135                // Second request (duplicated).
     136                $actual = wp_create_user_request( self::$non_registered_user_email, 'export_personal_data' );
     137
     138                $this->assertWPError( $actual );
     139                $this->assertSame( 'duplicate_request', $actual->get_error_code() );
     140        }
     141
     142        /**
     143         * Ensure emails are properly sanitized.
     144         *
     145         * @ticket 44707
     146         */
     147        public function test_sanitized_email() {
     148                $actual = wp_create_user_request( 'some(email<withinvalid\characters@local.test', 'export_personal_data' );
     149
     150                $this->assertNotWPError( $actual );
     151
     152                $post = get_post( $actual );
     153
     154                $this->assertSame( 'export_personal_data', $post->post_name );
     155                $this->assertSame( 'someemailwithinvalidcharacters@local.test', $post->post_title );
     156        }
     157
     158        /**
     159         * Ensure action names are properly sanitized.
     160         *
     161         * @ticket 44707
     162         */
     163        public function test_sanitized_action_name() {
     164                $actual = wp_create_user_request( self::$non_registered_user_email, 'some[custom*action\name' );
     165
     166                $this->assertNotWPError( $actual );
     167
     168                $post = get_post( $actual );
     169
     170                $this->assertSame( 'somecustomactionname', $post->post_name );
     171                $this->assertSame( self::$non_registered_user_email, $post->post_title );
     172        }
     173
     174        /**
     175         * Test a user request is created successfully for a registered user.
     176         *
     177         * @ticket 44707
     178         */
     179        public function test_create_request_registered_user() {
     180                wp_delete_post( self::$request_id, true );
     181
     182                $test_data = array(
     183                        'test-data'  => 'test value here',
     184                        'test index' => 'more privacy data',
     185                );
     186
     187                $actual = wp_create_user_request( self::$registered_user_email, 'export_personal_data', $test_data );
     188
     189                $this->assertNotWPError( $actual );
     190
     191                $post = get_post( $actual );
     192
     193                $this->assertSame( self::$user_id, (int) $post->post_author );
     194                $this->assertSame( 'export_personal_data', $post->post_name );
     195                $this->assertSame( self::$registered_user_email, $post->post_title );
     196                $this->assertSame( 'request-pending', $post->post_status );
     197                $this->assertSame( 'user_request', $post->post_type );
     198                $this->assertSame( wp_json_encode( $test_data ), $post->post_content );
     199        }
     200
     201        /**
     202         * Test a user request is created successfully for an non-registered user.
     203         *
     204         * @ticket 44707
     205         */
     206        public function test_create_request_unregistered_user() {
     207                wp_delete_post( self::$request_id, true );
     208
     209                $test_data = array(
     210                        'test-data'  => 'test value here',
     211                        'test index' => 'more privacy data',
     212                );
     213
     214                $actual = wp_create_user_request( self::$non_registered_user_email, 'export_personal_data', $test_data );
     215
     216                $this->assertNotWPError( $actual );
     217
     218                $post = get_post( $actual );
     219
     220                $this->assertSame( 0, (int) $post->post_author );
     221                $this->assertSame( 'export_personal_data', $post->post_name );
     222                $this->assertSame( self::$non_registered_user_email, $post->post_title );
     223                $this->assertSame( 'request-pending', $post->post_status );
     224                $this->assertSame( 'user_request', $post->post_type );
     225                $this->assertSame( wp_json_encode( $test_data ), $post->post_content );
     226        }
     227
     228        /**
     229         * Test that a pre-existing request for the same registered user that is not pending or confirmed status does not
     230         * block a new request.
     231         *
     232         * @ticket 44707
     233         */
     234        public function test_completed_request_does_not_block_new_request() {
     235                // Update first request.
     236                wp_update_post(
     237                        array(
     238                                'ID'          => self::$request_id,
     239                                'post_status' => 'request-completed', // Not 'request-pending' or 'request-confirmed'.
     240                        )
     241                );
     242
     243                // Second request.
     244                $actual = wp_create_user_request( self::$registered_user_email, 'export_personal_data' );
     245
     246                $this->assertNotWPError( $actual );
     247
     248                $post = get_post( $actual );
     249
     250                $this->assertSame( self::$registered_user_email, $post->post_title );
     251                $this->assertSame( 'request-pending', $post->post_status );
     252                $this->assertSame( 'user_request', $post->post_type );
     253        }
     254
     255        /**
     256         * Test that a pre-existing request for the same non-registered user that is not pending or confirmed status does not
     257         * block a new request.
     258         *
     259         * @ticket 44707
     260         */
     261        public function test_completed_request_does_not_block_new_request_for_unregistered_user() {
     262                wp_update_post(
     263                        array(
     264                                'ID'          => self::$request_id,
     265                                'post_author' => 0,
     266                                'post_title'  => self::$non_registered_user_email,
     267                                'post_status' => 'request-failed', // Not 'request-pending' or 'request-confirmed'.
     268                        )
     269                );
     270
     271                $actual = wp_create_user_request( self::$non_registered_user_email, 'export_personal_data' );
     272
     273                $this->assertNotWPError( $actual );
     274
     275                $post = get_post( $actual );
     276
     277                $this->assertSame( 0, (int) $post->post_author );
     278                $this->assertSame( 'export_personal_data', $post->post_name );
     279                $this->assertSame( self::$non_registered_user_email, $post->post_title );
     280                $this->assertSame( 'request-pending', $post->post_status );
     281                $this->assertSame( 'user_request', $post->post_type );
     282        }
     283
     284        /**
     285         * Test that an error from `wp_insert_post()` is returned.
     286         *
     287         * @ticket 44707
     288         */
     289        public function test_wp_error_returned_from_wp_insert_post() {
     290                wp_delete_post( self::$request_id, true );
     291
     292                add_filter( 'wp_insert_post_empty_content', '__return_true' );
     293                $actual = wp_create_user_request( self::$registered_user_email, 'export_personal_data' );
     294
     295                $this->assertWPError( $actual );
     296                $this->assertSame( 'empty_content', $actual->get_error_code() );
     297        }
     298}