WordPress.org

Make WordPress Core

Ticket #21195: 21195-ut.3.diff

File 21195-ut.3.diff, 20.3 KB (added by mdawaffe, 3 years ago)
  • tests/avatar.php

     
     1<?php 
     2 
     3/** 
     4 * Test get_avatar_url() and get_avatar() 
     5 * 
     6 * @group avatar 
     7 */ 
     8class Tests_Avatar extends WP_UnitTestCase { 
     9        const USER_EMAIL         = 'UsEr@exaMple.oRg'; 
     10        const DELETED_USER_EMAIL = 'dOdO@ExampLe.oRg'; 
     11        const GUEST_EMAIL        = 'GuesT@eXample.oRg'; 
     12 
     13        const USER_EMAIL_MD5          = '572c3489ea700045927076136a969e27'; // 2 == hexdec( "5" ) % 3 
     14        const DELETED_USER_EMAIL_MD5  = '7736907f09ecae4d1400c18f499a61f8'; // 1 == hexdec( "7" ) % 3 
     15        const GUEST_EMAIL_MD5         = 'cde48bd0bea0bbc6bc6bb02a461d946e'; // 0 == hexdec( "c" ) % 3 
     16 
     17        const UNKNOWN_COMMENT_TYPE = 'unknown'; 
     18        const ALLOWED_COMMENT_TYPE = 'allowed'; 
     19 
     20        var $user_id         = 0; 
     21        var $deleted_user_id = 0; 
     22 
     23        var $comment_by_user         = 0; 
     24        var $comment_by_deleted_user = 0; 
     25        var $comment_by_guest        = 0; 
     26        var $unknown_comment_type    = 0; 
     27        var $allowed_comment_type    = 0; 
     28 
     29        var $post_by_user = 0; 
     30 
     31        var $img_structure; 
     32 
     33        function setUp() { 
     34                parent::setUp(); 
     35 
     36                $this->user_id = $this->factory->user->create( array( 
     37                        'user_email' => self::USER_EMAIL, 
     38                ) ); 
     39 
     40                $this->deleted_user_id = $this->factory->user->create( array( 
     41                        'user_email' => self::DELETED_USER_EMAIL, 
     42                ) ); 
     43 
     44                $this->comment_by_user = $this->factory->comment->create( array( 
     45                        'user_id' => $this->user_id, 
     46                ) ); 
     47 
     48                $this->comment_by_deleted_user = $this->factory->comment->create( array( 
     49                        'user_id' => $this->deleted_user_id, 
     50                        'comment_author_email' => self::DELETED_USER_EMAIL, 
     51                ) ); 
     52 
     53                $this->comment_by_guest = $this->factory->comment->create( array( 
     54                        'user_id' => 0, 
     55                        'comment_author_email' => self::GUEST_EMAIL, 
     56                ) ); 
     57 
     58                $this->comment_by_noone = $this->factory->comment->create( array( 
     59                        'user_id' => 0, 
     60                        'comment_author_email' => '', 
     61                ) ); 
     62 
     63                $this->unknown_comment_type = $this->factory->comment->create( array( 
     64                        'user_id' => $this->user_id, 
     65                        'comment_type' => self::UNKNOWN_COMMENT_TYPE, 
     66                ) ); 
     67 
     68                $this->allowed_comment_type = $this->factory->comment->create( array( 
     69                        'user_id' => $this->user_id, 
     70                        'comment_type' => self::ALLOWED_COMMENT_TYPE, 
     71                ) ); 
     72 
     73                $this->post_by_user = $this->factory->post->create( array( 
     74                        'post_author' => $this->user_id, 
     75                ) ); 
     76 
     77                if ( is_multisite() ) { 
     78                        wpmu_delete_user( $this->deleted_user_id ); 
     79                } else { 
     80                        wp_delete_user( $this->deleted_user_id ); 
     81                } 
     82 
     83                $dom = new DomDocument; 
     84                $dom->loadHTML( '<img />' ); 
     85                $this->img_structure = $dom->documentElement->firstChild->firstChild; 
     86                foreach ( array( 'src', 'height', 'width', 'class', 'alt' ) as $name ) { 
     87                        $this->img_structure->setAttribute( $name, 'true' ); 
     88                } 
     89        }        
     90 
     91/* Tests */ 
     92 
     93        /** 
     94         * Make sure our tests are set up correctly. 
     95         * 
     96         * @dataProvider md5s 
     97         */ 
     98        function test_md5( $email, $expected_md5 ) { 
     99                $this->assertEquals( $expected_md5, md5( strtolower( trim( $email ) ) ) ); 
     100        } 
     101 
     102        function md5s() { 
     103                return array( 
     104                        // $email, $expected_md5 
     105                        array( self::USER_EMAIL        , self::USER_EMAIL_MD5 ), 
     106                        array( self::DELETED_USER_EMAIL, self::DELETED_USER_EMAIL_MD5 ), 
     107                        array( self::GUEST_EMAIL       , self::GUEST_EMAIL_MD5 ), 
     108                ); 
     109        } 
     110 
     111        /* Get Avatar By ... */ 
     112        /*      User ID */ 
     113 
     114        function test_by_user_id() { 
     115                $avatar_html = get_avatar( $this->user_id ); 
     116 
     117                $dom_img = $this->get_image_element( $avatar_html ); 
     118 
     119                $this->assertAvatarMatchesHash( self::USER_EMAIL_MD5, $dom_img ); 
     120        } 
     121 
     122        function test_by_user_id_deleted() { 
     123                $avatar_html = get_avatar( $this->deletede_user_id ); 
     124 
     125                $dom_img = $this->get_image_element( $avatar_html ); 
     126 
     127                $this->assertAvatarMatchesHash( '', $dom_img ); // User ID does not exist, so no email to hash 
     128 
     129                $this->assertAvatarHTMLHasClasses( 'avatar-default', $dom_img ); 
     130        } 
     131 
     132        function test_by_user_id_bad() { 
     133                $avatar_html = get_avatar( 0 ); 
     134 
     135                $dom_img = $this->get_image_element( $avatar_html ); 
     136 
     137                $this->assertAvatarMatchesHash( '', $dom_img ); 
     138 
     139                $this->assertAvatarHTMLHasClasses( 'avatar-default', $dom_img ); 
     140        } 
     141 
     142        function test_by_user_id_negative() { 
     143                $avatar_html = get_avatar( -1 * $this->user_id ); 
     144 
     145                $dom_img = $this->get_image_element( $avatar_html ); 
     146 
     147                $this->assertAvatarMatchesHash( self::USER_EMAIL_MD5, $dom_img ); 
     148        } 
     149 
     150        /*      Email Address or Hash */ 
     151 
     152        function emails() { 
     153                return array( 
     154                        // $email, $expected_hash 
     155                        array( self::USER_EMAIL             , self::USER_EMAIL_MD5 ), 
     156                        array( ' ' . self::USER_EMAIL . "\t", self::USER_EMAIL_MD5 ), // whitespace should be stripped before MD5ing 
     157                        array( 
     158                                sprintf( '%s@md5.gravatar.com', self::USER_EMAIL_MD5 ), // this is how you generate an avatar for a specific MD5 hash 
     159                                self::USER_EMAIL_MD5 
     160                        ), 
     161                ); 
     162        } 
     163 
     164        /** 
     165         * @dataProvider emails 
     166         */ 
     167        function test_by_email( $email, $expected_hash ) { 
     168                $avatar_html = get_avatar( $email ); 
     169 
     170                $dom_img = $this->get_image_element( $avatar_html ); 
     171 
     172                $this->assertAvatarMatchesHash( $expected_hash, $dom_img ); 
     173        } 
     174 
     175        /*      User */ 
     176 
     177        function test_by_user() { 
     178                $user = get_user_by( 'id', $this->user_id ); 
     179 
     180                $avatar_html = get_avatar( $user ); 
     181 
     182                $dom_img = $this->get_image_element( $avatar_html ); 
     183 
     184                $this->assertAvatarMatchesHash( self::USER_EMAIL_MD5, $dom_img ); 
     185        } 
     186 
     187        /*      Comment */ 
     188 
     189        function test_by_comment_by_user() { 
     190                $comment = get_comment( $this->comment_by_user ); 
     191 
     192                $avatar_html = get_avatar( $comment ); 
     193 
     194                $dom_img = $this->get_image_element( $avatar_html ); 
     195 
     196                $this->assertAvatarMatchesHash( self::USER_EMAIL_MD5, $dom_img ); 
     197        } 
     198 
     199        function test_by_comment_by_deleted_user() { 
     200                $comment = get_comment( $this->comment_by_deleted_user ); 
     201 
     202                $avatar_html = get_avatar( $comment ); 
     203 
     204                $dom_img = $this->get_image_element( $avatar_html ); 
     205 
     206                $this->assertAvatarMatchesHash( self::DELETED_USER_EMAIL_MD5, $dom_img ); // Comment object has comment_author_email, so should fallback to that after user_id not found 
     207        } 
     208 
     209        function test_by_comment_by_guest() { 
     210                $comment = get_comment( $this->comment_by_guest ); 
     211 
     212                $avatar_html = get_avatar( $comment ); 
     213 
     214                $dom_img = $this->get_image_element( $avatar_html ); 
     215 
     216                $this->assertAvatarMatchesHash( self::GUEST_EMAIL_MD5, $dom_img ); 
     217        } 
     218 
     219        function test_by_comment_by_noone() { 
     220                $comment = get_comment( $this->comment_by_noone ); 
     221 
     222                $avatar_html = get_avatar( $comment ); 
     223 
     224                $dom_img = $this->get_image_element( $avatar_html ); 
     225 
     226                $this->assertAvatarMatchesHash( '', $dom_img ); 
     227        } 
     228 
     229        function test_by_unknown_comment_type() { 
     230                $comment = get_comment( $this->unknown_comment_type ); 
     231 
     232                $this->assertEquals( self::UNKNOWN_COMMENT_TYPE, $comment->comment_type ); 
     233 
     234                $avatar_html = get_avatar( $comment ); 
     235 
     236                $this->assertFalse( $avatar_html ); 
     237        } 
     238 
     239        function test_by_allowed_comment_type() { 
     240                $comment = get_comment( $this->allowed_comment_type ); 
     241 
     242                $this->assertEquals( self::ALLOWED_COMMENT_TYPE, $comment->comment_type ); 
     243 
     244                add_filter( 'get_avatar_comment_types', array( $this, '_get_avatar_comment_types' ) ); 
     245                $avatar_html = get_avatar( $comment ); 
     246                remove_filter( 'get_avatar_comment_types', array( $this, '_get_avatar_comment_types' ) ); 
     247 
     248                $dom_img = $this->get_image_element( $avatar_html ); 
     249 
     250                $this->assertAvatarMatchesHash( self::USER_EMAIL_MD5, $dom_img ); 
     251        } 
     252 
     253        /*      Post */ 
     254 
     255        function test_by_post() { 
     256                $post = get_post( $this->post_by_user ); 
     257 
     258                $avatar_html = get_avatar( $post ); 
     259 
     260                $dom_img = $this->get_image_element( $avatar_html ); 
     261 
     262                $this->assertAvatarMatchesHash( self::USER_EMAIL_MD5, $dom_img ); 
     263        } 
     264 
     265        /* Parameters */ 
     266        /*      Default Values for all parameters */ 
     267        function test_default_values() { 
     268                $width = $height = 96; // $size          = 96 
     269                $d     = 'mm';         // $default       = '' -> mystery 
     270                $f     = false;        // $force_default = false 
     271                $alt   = '';           // $alt           = '' 
     272                $r     = 'g';          // $rating        = 'G' 
     273 
     274                $avatar_html = get_avatar( $this->user_id ); 
     275 
     276                // No specifics in input 
     277                $dom_img = $this->get_image_element( $avatar_html ); 
     278 
     279                // Test output matches expected defaults 
     280 
     281                $this->assertAvatarHTMLAttributesMatch( compact( 'width', 'height', 'alt' ), $dom_img ); 
     282 
     283                $this->assertAvatarURLQueryParametersMatch( compact( 'd', 'f', 'r' ), $dom_img ); 
     284 
     285                // Test default scheme 
     286                $this->assertStringStartsWith( 'http://', $dom_img->getAttribute( 'src' ) ); 
     287        } 
     288 
     289        /*      Size */ 
     290 
     291        function sizes() { 
     292                return array( 
     293                        // $size, $expected_size 
     294                        array(   255, 255 ), 
     295                        array(  -255, 255 ), 
     296                        array(     0,  96 ), 
     297                        array( 'bad',  96 ), 
     298                ); 
     299        } 
     300 
     301        /** 
     302         * @dataProvider sizes 
     303         */ 
     304        function test_size_parameter( $size, $expected_size ) { 
     305                $width = $height = $expected_size; 
     306 
     307                $avatar_html = get_avatar( $this->user_id, $size ); 
     308 
     309                $dom_img = $this->get_image_element( $avatar_html ); 
     310 
     311                $this->assertAvatarHTMLAttributesMatch( compact( 'width', 'height' ), $dom_img ); 
     312        } 
     313 
     314        /** 
     315         * @dataProvider sizes 
     316         */ 
     317        function test_size_arg( $size, $expected_size ) { 
     318                $width = $height = $expected_size; 
     319 
     320                $avatar_html = get_avatar( $this->user_id, compact( 'size' ) ); 
     321 
     322                $dom_img = $this->get_image_element( $avatar_html ); 
     323 
     324                $this->assertAvatarHTMLAttributesMatch( compact( 'width', 'height' ), $dom_img ); 
     325        } 
     326 
     327        /*      Default */ 
     328 
     329        function defaults() { 
     330                return array( 
     331                        // $default, $expected_d 
     332                        array( 'mm'              , 'mm' ), 
     333                        array( 'mystery'         , 'mm' ), 
     334                        array( 'mysteryman'      , 'mm' ), 
     335                        array( '404'             , '404' ), 
     336                        array(                404, '404' ), 
     337                        array( 'retro'           , 'retro' ), 
     338                        array( 'monsterid'       , 'monsterid' ), 
     339                        array( 'wavatar'         , 'wavatar' ), 
     340                        array( 'identicon'       , 'identicon' ), 
     341                        array( 'blank'           , 'blank' ), 
     342                        array( 'gravatar_default', false ), // There should be no d query string parameter 
     343                        array( 
     344                                'http://example.org/image.jpg?foo=bar%2F&one=two#fragment', 
     345                                'http://example.org/image.jpg?foo=bar%2F&one=two#fragment', 
     346                        ), 
     347                ); 
     348        } 
     349 
     350        /** 
     351         * @dataProvider defaults 
     352         */ 
     353        function test_default_parameter( $default, $expected_d ) { 
     354                $d = $expected_d; 
     355                $avatar_html = get_avatar( $this->user_id, 96, $default ); 
     356 
     357                $dom_img = $this->get_image_element( $avatar_html ); 
     358 
     359                $this->assertAvatarURLQueryParametersMatch( compact( 'd' ), $dom_img ); 
     360        } 
     361 
     362        /** 
     363         * @dataProvider defaults 
     364         */ 
     365        function test_default_arg( $default, $expected_d ) { 
     366                $d = $expected_d; 
     367                $avatar_html = get_avatar( $this->user_id, compact( 'default' ) ); 
     368 
     369                $dom_img = $this->get_image_element( $avatar_html ); 
     370 
     371                $this->assertAvatarURLQueryParametersMatch( compact( 'd' ), $dom_img ); 
     372        } 
     373 
     374        /*      Alt */ 
     375 
     376        function alts() { 
     377                return array( 
     378                        // $alt 
     379                        array( 'a\'b"c<d>h&i%j\\k' ), 
     380                ); 
     381        } 
     382 
     383        /** 
     384         * @dataProvider alts 
     385         */ 
     386        function test_alt_parameter( $alt ) { 
     387                $avatar_html = get_avatar( $this->user_id, 96, '', $alt ); 
     388 
     389                $dom_img = $this->get_image_element( $avatar_html ); 
     390 
     391                $this->assertAvatarHTMLAttributesMatch( compact( 'alt' ), $dom_img ); 
     392        } 
     393 
     394        /** 
     395         * @dataProvider alts 
     396         */ 
     397        function test_alt_arg( $alt ) { 
     398                $avatar_html = get_avatar( $this->user_id, compact( 'alt' ) ); 
     399 
     400                $dom_img = $this->get_image_element( $avatar_html ); 
     401 
     402                $this->assertAvatarHTMLAttributesMatch( compact( 'alt' ), $dom_img ); 
     403        } 
     404 
     405        /*      Extraneous Parameter */ 
     406 
     407        // The $size, $default, and $alt parameter should still work even if there are extraneous parameters tacked on the end 
     408        function test_extraneous_parameter() { 
     409                $s = 255; 
     410                $d = '404'; 
     411                $alt = 'foo'; 
     412                $avatar_html = get_avatar( $this->user_id, $s, $d, $alt, 'extraneous' ); 
     413 
     414                $dom_img = $this->get_image_element( $avatar_html ); 
     415 
     416                $this->assertAvatarURLQueryParametersMatch( compact( 's', 'd' ), $dom_img ); 
     417 
     418                $this->assertAvatarHTMLAttributesMatch( compact( 'alt' ), $dom_img ); 
     419        } 
     420 
     421        /*      Force Default */ 
     422 
     423        function test_force_default() { 
     424                $force_default = true; 
     425                $f = 'y'; 
     426                $avatar_html = get_avatar( $this->user_id, compact( 'force_default' ) ); 
     427 
     428                $dom_img = $this->get_image_element( $avatar_html ); 
     429 
     430                $this->assertAvatarURLQueryParametersMatch( compact( 'f' ), $dom_img ); 
     431 
     432                $this->assertAvatarHTMLHasClasses( 'avatar-default', $dom_img ); 
     433        } 
     434 
     435        /*      Rating */ 
     436 
     437        function test_rating() { 
     438                $rating = 'PG'; 
     439                $r = 'pg'; 
     440                $avatar_html = get_avatar( $this->user_id, compact( 'rating' ) ); 
     441 
     442                $dom_img = $this->get_image_element( $avatar_html ); 
     443 
     444                $this->assertAvatarURLQueryParametersMatch( compact( 'r' ), $dom_img ); 
     445        } 
     446 
     447        /*      Scheme */ 
     448 
     449        function test_scheme_https() { 
     450                $scheme = 'https'; 
     451                $avatar_html = get_avatar( $this->user_id, compact( 'scheme' ) ); 
     452 
     453                $dom_img = $this->get_image_element( $avatar_html ); 
     454 
     455                $this->assertStringStartsWith( 'https://', $dom_img->getAttribute( 'src' ) ); 
     456        } 
     457 
     458        /** 
     459         * @backupGlobals enabled 
     460         */ 
     461        function test_scheme_default_over_ssl() { 
     462                $_SERVER['HTTPS'] = 'ON'; 
     463 
     464                $avatar_html = get_avatar( $this->user_id ); 
     465 
     466                $dom_img = $this->get_image_element( $avatar_html ); 
     467 
     468                $this->assertStringStartsWith( 'https://', $dom_img->getAttribute( 'src' ) ); 
     469        } 
     470 
     471        /*      Class */ 
     472 
     473        function classes() { 
     474                return array( 
     475                        // $class, $expected_classes 
     476                        array( 'bar    foo'             , array( 'foo', 'bar' ) ), 
     477                        array( array( 'foo  ', '  bar' ), array( 'foo', 'bar' ) ), 
     478                ); 
     479        } 
     480 
     481        /** 
     482         * @dataProvider classes 
     483         */ 
     484        function test_class( $class, $expected_classes ) { 
     485                $avatar_html = get_avatar( $this->user_id, compact( 'class' ) ); 
     486 
     487                $dom_img = $this->get_image_element( $avatar_html ); 
     488 
     489                $this->assertAvatarHTMLHasClasses( $expected_classes, $dom_img ); 
     490        } 
     491 
     492        /*      Force Display */ 
     493 
     494        function test_force_display() { 
     495                update_option( 'show_avatars', false ); // Turn off avatars 
     496 
     497                $avatar_html = get_avatar( $this->user_id, array( 'force_display' => true ) ); 
     498 
     499                $this->get_image_element( $avatar_html ); 
     500        } 
     501 
     502        /* Options */ 
     503 
     504        function test_option_show_avatars() { 
     505                update_option( 'show_avatars', false ); 
     506 
     507                $avatar_html = get_avatar( $this->user_id ); 
     508 
     509                $this->assertFalse( $avatar_html ); 
     510        } 
     511 
     512        function test_option_avatar_default() { 
     513                update_option( 'avatar_default', '404' ); 
     514 
     515                $default = $d = '404'; 
     516                $avatar_html = get_avatar( $this->user_id, 96, $default ); 
     517 
     518                $dom_img = $this->get_image_element( $avatar_html ); 
     519 
     520                $this->assertAvatarURLQueryParametersMatch( compact( 'd' ), $dom_img ); 
     521        } 
     522 
     523        function test_option_avatar_rating_false() { 
     524                update_option( 'avatar_rating', false ); 
     525 
     526                $avatar_html = get_avatar( $this->user_id ); 
     527 
     528                $dom_img = $this->get_image_element( $avatar_html ); 
     529 
     530                $this->assertAvatarURLQueryParametersMatch( array( 'r' => false ), $dom_img ); 
     531        } 
     532 
     533        function test_option_avatar_rating_PG() { 
     534                update_option( 'avatar_rating', 'PG' ); 
     535 
     536                $avatar_html = get_avatar( $this->user_id ); 
     537 
     538                $dom_img = $this->get_image_element( $avatar_html ); 
     539 
     540                $this->assertAvatarURLQueryParametersMatch( array( 'r' => 'pg' ), $dom_img ); 
     541        } 
     542 
     543        /* Filters */ 
     544 
     545        /*      pre_get_avatar_url, get_avatar_url */ 
     546 
     547        // Used for both get_avatar and get_avatar_url filters 
     548        function get_avatar_filters() { 
     549                return array( 
     550                        array( 'pre_get_avatar' ), 
     551                        array( 'get_avatar' ), 
     552                ); 
     553        } 
     554 
     555        /** 
     556         * @requires function get_avatar_url 
     557         * @dataProvider get_avatar_filters 
     558         */ 
     559        function test_get_avatar_url_filters( $filter ) { 
     560                add_filter( "{$filter}_url", '__return_zero' ); // pre_get_avatar_url, get_avatar_url 
     561 
     562                $avatar_url = get_avatar_url( $this->user_id ); 
     563 
     564                remove_filter( "{$filter}_url", '__return_zero' ); 
     565 
     566                $this->assertSame( 0, $avatar_url ); 
     567        } 
     568 
     569        /** 
     570         * @dataProvider get_avatar_filters 
     571         */ 
     572        function test_get_avatar_url_filters_and_process_args( $filter ) { 
     573                $width = $height = 255; 
     574 
     575                add_filter( "{$filter}_url", array( $this, '_get_avatar_url_and_process_args' ), 10, 3 ); // pre_get_avatar_url, get_avatar_url 
     576 
     577                $avatar_html = get_avatar( $this->user_id ); 
     578 
     579                remove_filter( "{$filter}_url", array( $this, '_get_avatar_url_and_process_args' ), 10, 3 ); 
     580 
     581                $dom_img = $this->get_image_element( $avatar_html ); 
     582 
     583                $this->assertAvatarHTMLAttributesMatch( compact( 'width', 'height' ), $dom_img ); 
     584 
     585                $this->assertAvatarMatchesHash( 'zzz', $dom_img ); 
     586 
     587        } 
     588 
     589        /*      pre_get_avatar, get_avatar */ 
     590 
     591        /** 
     592         * @dataProvider get_avatar_filters 
     593         */ 
     594        function test_get_avatar_filters( $filter ) { 
     595                add_filter( $filter, '__return_zero' ); // pre_get_avatar, get_avatar 
     596 
     597                $avatar_html = get_avatar( $this->user_id ); 
     598 
     599                remove_filter( $filter, '__return_zero' ); 
     600 
     601                $this->assertSame( 0, $avatar_html ); 
     602        } 
     603 
     604        /* Domain Sharding */ 
     605 
     606        function domain_shards() { 
     607                return array( 
     608                        array( self::GUEST_EMAIL       , 0 ), 
     609                        array( self::DELETED_USER_EMAIL, 1 ), 
     610                        array( self::USER_EMAIL        , 2 ), 
     611                ); 
     612        } 
     613 
     614        /** 
     615         * @dataProvider domain_shards 
     616         */ 
     617        function test_domain_sharding( $email, $shard ) { 
     618                $avatar_html = get_avatar( $email ); 
     619 
     620                $dom_img = $this->get_image_element( $avatar_html ); 
     621 
     622                $this->assertStringStartsWith( "http://{$shard}.", $dom_img->getAttribute( 'src' ) ); 
     623        } 
     624 
     625/* Helpers */ 
     626 
     627        /** 
     628         * Converts IMG tag HTML to a DOM_Element and asserts that the markup matches the expected structure. 
     629         * 
     630         * @param string $html_string IMG tag 
     631         * 
     632         * @return DOM_Element IMG element 
     633         */ 
     634        private function get_image_element( $html_string ) { 
     635                $dom = new DOMDocument; 
     636                $success = $dom->loadHTML( $html_string ); 
     637                $this->assertTrue( $success, 'Invalid HTML' ); 
     638 
     639                $this->assertTrue( $dom->documentElement->firstChild->firstChild->hasAttribute( 'src' ) ); 
     640 
     641                $this->assertEqualXMLStructure( $this->img_structure, $dom->documentElement->firstChild->firstChild, true, 'HTML does not match expected value' ); 
     642 
     643                return $dom->documentElement->firstChild->firstChild; 
     644        } 
     645 
     646        // Filter for ::test_by_allowed_comment_type() 
     647        function _get_avatar_comment_types( $comment_types ) { 
     648                $comment_types[] = self::ALLOWED_COMMENT_TYPE; 
     649 
     650                return $comment_types; 
     651        } 
     652 
     653        // Filter for ::test_get_avatar_url_filters_and_process_args() 
     654        function _get_avatar_url_and_process_args( $avatar_url, $id_or_email, &$args ) { 
     655                $args['size'] = 255; 
     656 
     657                return 'http://0.gravatar.com/avatar/zzz'; 
     658        } 
     659 
     660/* Assertions */ 
     661 
     662        /** 
     663         * @param string $expected_hash 
     664         * @param DOM_Element $dom_img 
     665         */ 
     666        private function assertAvatarMatchesHash( $expected_hash, $dom_img ) { 
     667                $src = $dom_img->getAttribute( 'src' ); 
     668 
     669                $this->assertRegExp( sprintf( '#/avatar/%s(/|\?|$)#', preg_quote( $expected_hash, '#' ) ), $src, "Hash mismatch: '$src' !~ '$expected_hash'" ); 
     670        } 
     671 
     672        /** 
     673         * @param array $expected_parameters key/value array of expected query string parameters in the IMG's src URL.  To expect a parameter to net be present, pass false as the value. 
     674         * @param DOM_Element $dom_img 
     675         */ 
     676        private function assertAvatarURLQueryParametersMatch( $expected_parameters, $dom_img ) { 
     677                $src = $dom_img->getAttribute( 'src' ); 
     678 
     679                $query = parse_url( $src, PHP_URL_QUERY ); 
     680                wp_parse_str( $query, $query_args ); 
     681 
     682                $expected_parameters = wp_parse_args( $expected_parameters ); 
     683 
     684                foreach ( $expected_parameters as $key => $value ) { 
     685                        if ( false === $value ) { 
     686                                $this->assertArrayNotHasKey( $key, $query_args ); 
     687                        } else { 
     688                                $this->assertArrayHasKey( $key, $query_args ); 
     689                                $this->assertEquals( $value, $query_args[$key] ); 
     690                        } 
     691                } 
     692        } 
     693 
     694        /** 
     695         * @param array $expected_atttributes key/value array of expected HTML attributes on the IMG element.  To expect a attribute to be present but not care about the value, pass null as the value. 
     696         * @param DOM_Element $dom_img 
     697         */ 
     698        private function assertAvatarHTMLAttributesMatch( $expected_attributes, $dom_img ) { 
     699                foreach ( $expected_attributes as $name => $value ) { 
     700                        if ( is_null( $value ) ) { 
     701                                $this->assertTrue( $dom_img->hasAttribute( $name ) ); 
     702                        } else { 
     703                                $this->assertEquals( $value, $dom_img->getAttribute( $name ) ); 
     704                        } 
     705                } 
     706        } 
     707        /** 
     708         * @param string|array $expected_classes expected classes on the IMG element. 
     709         * @param DOM_Element $dom_img 
     710         */ 
     711        private function assertAvatarHTMLHasClasses( $expected_classes, $dom_img ) { 
     712                $expected_classes = preg_split( '/\s+/', join( ' ', (array) $expected_classes ), -1, PREG_SPLIT_NO_EMPTY ); 
     713 
     714                $actual_classes = $dom_img->getAttribute( 'class' ); 
     715                $actual_classes = preg_split( '/\s+/', join( ' ', (array) $actual_classes ), -1, PREG_SPLIT_NO_EMPTY ); 
     716 
     717                foreach ( $expected_classes as $expected_class ) { 
     718                        $this->assertContains( $expected_class, $actual_classes, "Missing class $expected_class" ); 
     719                } 
     720        } 
     721}