Skip to:
Content

bbPress.org

Ticket #2801: 2801.01.patch

File 2801.01.patch, 49.2 KB (added by thebrandonallen, 10 years ago)

Test improvements

  • new file tests/phpunit/testcases/common/query.php 

    diff --git tests/phpunit/testcases/common/query.php tests/phpunit/testcases/common/query.php
new file mode 100644
index 0000000..9eeb7b6
    - +  
     1<?php
     2
     3/**
     4 * Tests for the common query functions.
     5 *
     6 * @group common
     7 * @group functions
     8 * @group query
     9 */
     10class BBP_Tests_Common_Functions_Query extends BBP_UnitTestCase {
     11
     12        /**
     13         * @covers ::bbp_get_public_child_count
     14         * @group  counts
     15         */
     16        public function test_bbp_get_public_child_count() {
     17                $f = $this->factory->forum->create();
     18
     19                // Test initial forum public child counts
     20                $count = bbp_get_public_child_count( $f, bbp_get_forum_post_type() );
     21                $this->assertSame( 0, $count );
     22
     23                $count = bbp_get_public_child_count( $f, bbp_get_topic_post_type() );
     24                $this->assertSame( 0, $count );
     25
     26                /* Sub-Forums **************************************************************/
     27
     28                $this->factory->forum->create_many( 3, array(
     29                        'post_parent' => $f,
     30                ) );
     31
     32                $this->factory->forum->create( array(
     33                        'post_parent' => $f,
     34                        'post_status' => bbp_get_private_status_id(),
     35                ) );
     36
     37                wp_cache_flush();
     38                $count = bbp_get_public_child_count( $f, bbp_get_forum_post_type() );
     39                $this->assertSame( 3, $count );
     40
     41                $this->factory->forum->create_many( 2, array(
     42                        'post_parent' => $f,
     43                ) );
     44
     45                // Test that previous value was cached
     46                $count = bbp_get_public_child_count( $f, bbp_get_forum_post_type() );
     47                $this->assertSame( 3, $count );
     48
     49                // Test with a fresh count
     50                wp_cache_flush();
     51                $count = bbp_get_public_child_count( $f, bbp_get_forum_post_type() );
     52                $this->assertSame( 5, $count );
     53
     54                /* Topics ******************************************************************/
     55
     56                $t1 = $this->factory->topic->create_many( 3, array(
     57                        'post_parent' => $f,
     58                ) );
     59
     60                $this->factory->topic->create( array(
     61                        'post_parent' => $f,
     62                        'post_status' => bbp_get_spam_status_id(),
     63                ) );
     64
     65                $count = bbp_get_public_child_count( $f, bbp_get_topic_post_type() );
     66                $this->assertSame( 3, $count );
     67
     68                $this->factory->topic->create_many( 2, array(
     69                        'post_parent' => $f,
     70                ) );
     71
     72                // Test that previous value was cached
     73                $count = bbp_get_public_child_count( $f, bbp_get_topic_post_type() );
     74                $this->assertSame( 3, $count );
     75
     76                // Test with a fresh count
     77                wp_cache_flush();
     78                $count = bbp_get_public_child_count( $f, bbp_get_topic_post_type() );
     79                $this->assertSame( 5, $count );
     80
     81                /* Replies *****************************************************************/
     82
     83                $this->factory->reply->create_many( 3, array(
     84                        'post_parent' => $t1[0],
     85                ) );
     86
     87                $this->factory->reply->create( array(
     88                        'post_parent' => $t1[0],
     89                        'post_status' => bbp_get_spam_status_id(),
     90                ) );
     91
     92                $count = bbp_get_public_child_count( $t1[0], bbp_get_reply_post_type() );
     93                $this->assertSame( 3, $count );
     94
     95                $this->factory->reply->create_many( 2, array(
     96                        'post_parent' => $t1[0],
     97                ) );
     98
     99                // Test that previous value was cached
     100                $count = bbp_get_public_child_count( $t1[0], bbp_get_reply_post_type() );
     101                $this->assertSame( 3, $count );
     102
     103                // Test with a fresh count
     104                wp_cache_flush();
     105                $count = bbp_get_public_child_count( $t1[0], bbp_get_reply_post_type() );
     106                $this->assertSame( 5, $count );
     107        }
     108
     109        /**
     110         * @covers ::bbp_get_public_child_ids
     111         */
     112        public function test_bbp_get_public_child_ids() {
     113                $f = $this->factory->forum->create();
     114
     115                // Test initial forum public child counts
     116                $count = count( bbp_get_public_child_ids( $f, bbp_get_forum_post_type() ) );
     117                $this->assertSame( 0, $count );
     118
     119                $count = count( bbp_get_public_child_ids( $f, bbp_get_topic_post_type() ) );
     120                $this->assertSame( 0, $count );
     121
     122                /* Sub-Forums **************************************************************/
     123
     124                $this->factory->forum->create_many( 3, array(
     125                        'post_parent' => $f,
     126                ) );
     127
     128                $this->factory->forum->create( array(
     129                        'post_parent' => $f,
     130                        'post_status' => bbp_get_private_status_id(),
     131                ) );
     132
     133                wp_cache_flush();
     134                $count = count( bbp_get_public_child_ids( $f, bbp_get_forum_post_type() ) );
     135                $this->assertSame( 3, $count );
     136
     137                $this->factory->forum->create_many( 2, array(
     138                        'post_parent' => $f,
     139                ) );
     140
     141                // Test that previous value was cached
     142                $count = count( bbp_get_public_child_ids( $f, bbp_get_forum_post_type() ) );
     143                $this->assertSame( 3, $count );
     144
     145                // Test with a fresh count
     146                wp_cache_flush();
     147                $count = count( bbp_get_public_child_ids( $f, bbp_get_forum_post_type() ) );
     148                $this->assertSame( 5, $count );
     149
     150                /* Topics ******************************************************************/
     151
     152                $t1 = $this->factory->topic->create_many( 3, array(
     153                        'post_parent' => $f,
     154                ) );
     155
     156                $this->factory->topic->create( array(
     157                        'post_parent' => $f,
     158                        'post_status' => bbp_get_spam_status_id(),
     159                ) );
     160
     161                $count = count( bbp_get_public_child_ids( $f, bbp_get_topic_post_type() ) );
     162                $this->assertSame( 3, $count );
     163
     164                $this->factory->topic->create_many( 2, array(
     165                        'post_parent' => $f,
     166                ) );
     167
     168                // Test that previous value was cached
     169                $count = count( bbp_get_public_child_ids( $f, bbp_get_topic_post_type() ) );
     170                $this->assertSame( 3, $count );
     171
     172                // Test with a fresh count
     173                wp_cache_flush();
     174                $count = count( bbp_get_public_child_ids( $f, bbp_get_topic_post_type() ) );
     175                $this->assertSame( 5, $count );
     176
     177                /* Replies *****************************************************************/
     178
     179                $this->factory->reply->create_many( 3, array(
     180                        'post_parent' => $t1[0],
     181                ) );
     182
     183                $this->factory->reply->create( array(
     184                        'post_parent' => $t1[0],
     185                        'post_status' => bbp_get_spam_status_id(),
     186                ) );
     187
     188                $count = count( bbp_get_public_child_ids( $t1[0], bbp_get_reply_post_type() ) );
     189                $this->assertSame( 3, $count );
     190
     191                $this->factory->reply->create_many( 2, array(
     192                        'post_parent' => $t1[0],
     193                ) );
     194
     195                // Test that previous value was cached
     196                $count = count( bbp_get_public_child_ids( $t1[0], bbp_get_reply_post_type() ) );
     197                $this->assertSame( 3, $count );
     198
     199                // Test with a fresh count
     200                wp_cache_flush();
     201                $count = count( bbp_get_public_child_ids( $t1[0], bbp_get_reply_post_type() ) );
     202                $this->assertSame( 5, $count );
     203        }
     204
     205        /**
     206         * @covers ::bbp_get_all_child_ids
     207         */
     208        public function test_bbp_get_all_child_ids() {
     209                $f = $this->factory->forum->create();
     210
     211                // Test initial forum public child counts
     212                $count = count( bbp_get_all_child_ids( $f, bbp_get_forum_post_type() ) );
     213                $this->assertSame( 0, $count );
     214
     215                $count = count( bbp_get_all_child_ids( $f, bbp_get_topic_post_type() ) );
     216                $this->assertSame( 0, $count );
     217
     218                /* Sub-Forums **************************************************************/
     219
     220                $this->factory->forum->create_many( 3, array(
     221                        'post_parent' => $f,
     222                ) );
     223
     224                $this->factory->forum->create( array(
     225                        'post_parent' => $f,
     226                        'post_status' => bbp_get_private_status_id(),
     227                ) );
     228
     229                wp_cache_flush();
     230                $count = count( bbp_get_all_child_ids( $f, bbp_get_forum_post_type() ) );
     231                $this->assertSame( 4, $count );
     232
     233                $this->factory->forum->create_many( 2, array(
     234                        'post_parent' => $f,
     235                ) );
     236
     237                // Test that previous value was cached
     238                $count = count( bbp_get_all_child_ids( $f, bbp_get_forum_post_type() ) );
     239                $this->assertSame( 4, $count );
     240
     241                // Test with a fresh count
     242                wp_cache_flush();
     243                $count = count( bbp_get_all_child_ids( $f, bbp_get_forum_post_type() ) );
     244                $this->assertSame( 6, $count );
     245
     246                /* Topics ******************************************************************/
     247
     248                $t1 = $this->factory->topic->create_many( 3, array(
     249                        'post_parent' => $f,
     250                ) );
     251
     252                $this->factory->topic->create( array(
     253                        'post_parent' => $f,
     254                        'post_status' => bbp_get_spam_status_id(),
     255                ) );
     256
     257                wp_cache_flush();
     258                $count = count( bbp_get_all_child_ids( $f, bbp_get_topic_post_type() ) );
     259                $this->assertSame( 4, $count );
     260
     261                $this->factory->topic->create_many( 2, array(
     262                        'post_parent' => $f,
     263                ) );
     264
     265                // Test that previous value was cached
     266                $count = count( bbp_get_all_child_ids( $f, bbp_get_topic_post_type() ) );
     267                $this->assertSame( 4, $count );
     268
     269                // Test with a fresh count
     270                wp_cache_flush();
     271                $count = count( bbp_get_all_child_ids( $f, bbp_get_topic_post_type() ) );
     272                $this->assertSame( 6, $count );
     273
     274                /* Replies *****************************************************************/
     275
     276                $this->factory->reply->create_many( 3, array(
     277                        'post_parent' => $t1[0],
     278                ) );
     279
     280                $this->factory->reply->create( array(
     281                        'post_parent' => $t1[0],
     282                        'post_status' => bbp_get_spam_status_id(),
     283                ) );
     284
     285                $count = count( bbp_get_all_child_ids( $t1[0], bbp_get_reply_post_type() ) );
     286                $this->assertSame( 4, $count );
     287
     288                $this->factory->reply->create_many( 2, array(
     289                        'post_parent' => $t1[0],
     290                ) );
     291
     292                // Test that previous value was cached
     293                $count = count( bbp_get_all_child_ids( $t1[0], bbp_get_reply_post_type() ) );
     294                $this->assertSame( 4, $count );
     295
     296                // Test with a fresh count
     297                wp_cache_flush();
     298                $count = count( bbp_get_all_child_ids( $t1[0], bbp_get_reply_post_type() ) );
     299                $this->assertSame( 6, $count );
     300        }
     301}

  • tests/phpunit/testcases/forums/functions/counts.php 

    diff --git tests/phpunit/testcases/forums/functions/counts.php tests/phpunit/testcases/forums/functions/counts.php
index 74f83eb..ea4b157 100644
     
    1010class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase {
    1111
    1212        /**
     13         * Generic function to test the counts on a new topic
     14         */
     15        public function test_bbp_forum_new_topic_counts() {
     16                $f = $this->factory->forum->create();
     17                $t1 = $this->factory->topic->create( array(
     18                        'post_parent' => $f,
     19                        'post_author' => bbp_get_current_user_id(),
     20                        'topic_meta' => array(
     21                                'forum_id' => $f,
     22                        ),
     23                ) );
     24                $u = $this->factory->user->create();
     25
     26                // Cheating here, but we need $_SERVER['SERVER_NAME'] to be set
     27                $this->setUp_wp_mail( false );
     28
     29                // Simulate the 'bbp_new_topic' action
     30                do_action( 'bbp_new_topic', $t1, $f, false, get_post_field( 'post_author', $t1 ) );
     31
     32                // Reverse our changes
     33                $this->tearDown_wp_mail( false );
     34
     35                $count = bbp_get_forum_topic_count( $f, true, true );
     36                $this->assertSame( 1, $count );
     37
     38                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     39                $this->assertSame( 0, $count );
     40
     41                $t2 = $this->factory->topic->create( array(
     42                        'post_parent' => $f,
     43                        'post_author' => $u,
     44                        'topic_meta' => array(
     45                                'forum_id' => $f,
     46                        ),
     47                ) );
     48
     49                bbp_clean_post_cache( $t2 );
     50
     51                // Cheating here, but we need $_SERVER['SERVER_NAME'] to be set
     52                $this->setUp_wp_mail( false );
     53
     54                // Simulate the 'bbp_new_topic' action
     55                do_action( 'bbp_new_topic', $t2, $f, false, get_post_field( 'post_author', $t2 ) );
     56
     57                // Reverse our changes
     58                $this->tearDown_wp_mail( false );
     59
     60                $count = bbp_get_forum_topic_count( $f, true, true );
     61                $this->assertSame( 2, $count );
     62
     63                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     64                $this->assertSame( 0, $count );
     65        }
     66
     67        /**
     68         * Generic function to test the counts on a deleted topic
     69         */
     70        public function test_bbp_forum_deleted_topic_counts() {
     71                $f = $this->factory->forum->create();
     72                $t = $this->factory->topic->create_many( 3, array(
     73                        'post_parent' => $f,
     74                        'topic_meta' => array(
     75                                'forum_id' => $f,
     76                        ),
     77                ) );
     78                $r1 = $this->factory->reply->create_many( 2, array(
     79                        'post_parent' => $t[0],
     80                        'reply_meta' => array(
     81                                'forum_id' => $f,
     82                                'topic_id' => $t[0],
     83                        ),
     84                ) );
     85                $r2 = $this->factory->reply->create_many( 2, array(
     86                        'post_parent' => $t[1],
     87                        'reply_meta' => array(
     88                                'forum_id' => $f,
     89                                'topic_id' => $t[1],
     90                        ),
     91                ) );
     92
     93                bbp_clean_post_cache( $f );
     94
     95                $count = bbp_update_forum_topic_count( $f );
     96                $this->assertSame( 3, $count );
     97
     98                $count = bbp_update_forum_topic_count_hidden( $f );
     99                $this->assertSame( 0, $count );
     100
     101                $count = bbp_update_forum_reply_count( $f );
     102                $this->assertSame( 4, $count );
     103
     104                bbp_clean_post_cache( $t[2] );
     105                bbp_spam_topic( $t[2] );
     106
     107                $count = bbp_get_forum_topic_count( $f, true, true );
     108                $this->assertSame( 2, $count );
     109
     110                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     111                $this->assertSame( 1, $count );
     112
     113                $count = bbp_get_forum_reply_count( $f, true, true );
     114                $this->assertSame( 4, $count );
     115
     116                wp_delete_post( $t[1], true );
     117                wp_delete_post( $t[2], true );
     118
     119                $count = bbp_get_forum_topic_count( $f, true, true );
     120                $this->assertSame( 1, $count );
     121
     122                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     123                $this->assertSame( 0, $count );
     124
     125                $count = bbp_get_forum_reply_count( $f, true, true );
     126                $this->assertSame( 2, $count );
     127        }
     128
     129        /**
     130         * Generic function to test the counts on a trashed/untrashed topic
     131         */
     132        public function test_bbp_forum_trashed_untrashed_topic_counts() {
     133                $f = $this->factory->forum->create();
     134                $t = $this->factory->topic->create_many( 3, array(
     135                        'post_parent' => $f,
     136                        'topic_meta' => array(
     137                                'forum_id' => $f,
     138                        ),
     139                ) );
     140                $r1 = $this->factory->reply->create_many( 2, array(
     141                        'post_parent' => $t[1],
     142                        'reply_meta' => array(
     143                                'forum_id' => $f,
     144                                'topic_id' => $t[1],
     145                        ),
     146                ) );
     147                $r2 = $this->factory->reply->create_many( 2, array(
     148                        'post_parent' => $t[2],
     149                        'reply_meta' => array(
     150                                'forum_id' => $f,
     151                                'topic_id' => $t[2],
     152                        ),
     153                ) );
     154
     155                bbp_clean_post_cache( $f );
     156
     157                $count = bbp_update_forum_topic_count( $f );
     158                $this->assertSame( 3, $count );
     159
     160                $count = bbp_update_forum_topic_count_hidden( $f );
     161                $this->assertSame( 0, $count );
     162
     163                $count = bbp_update_forum_reply_count( $f );
     164                $this->assertSame( 4, $count );
     165
     166                wp_trash_post( $t[2] );
     167
     168                $count = bbp_get_forum_topic_count( $f, true, true );
     169                $this->assertSame( 2, $count );
     170
     171                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     172                $this->assertSame( 1, $count );
     173
     174                $count = bbp_get_forum_reply_count( $f, true, true );
     175                $this->assertSame( 2, $count );
     176
     177                $count = bbp_get_forum_reply_count( $f, true, true );
     178                $this->assertSame( 2, $count );
     179
     180                wp_untrash_post( $t[2] );
     181
     182                $count = bbp_get_forum_topic_count( $f, true, true );
     183                $this->assertSame( 3, $count );
     184
     185                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     186                $this->assertSame( 0, $count );
     187
     188                $count = bbp_get_forum_reply_count( $f, true, true );
     189                $this->assertSame( 4, $count );
     190        }
     191
     192        /**
     193         * Generic function to test the counts on a spammed/unspammed topic
     194         */
     195        public function test_bbp_forum_spammed_unspammed_topic_counts() {
     196                $f = $this->factory->forum->create();
     197                $t = $this->factory->topic->create_many( 3, array(
     198                        'post_parent' => $f,
     199                        'topic_meta' => array(
     200                                'forum_id' => $f,
     201                        ),
     202                ) );
     203                $r1 = $this->factory->reply->create_many( 2, array(
     204                        'post_parent' => $t[1],
     205                        'reply_meta' => array(
     206                                'forum_id' => $f,
     207                                'topic_id' => $t[1],
     208                        ),
     209                ) );
     210                $r2 = $this->factory->reply->create_many( 2, array(
     211                        'post_parent' => $t[2],
     212                        'reply_meta' => array(
     213                                'forum_id' => $f,
     214                                'topic_id' => $t[2],
     215                        ),
     216                ) );
     217
     218                bbp_clean_post_cache( $f );
     219
     220                $count = bbp_update_forum_topic_count( $f );
     221                $this->assertSame( 3, $count );
     222
     223                $count = bbp_update_forum_topic_count_hidden( $f );
     224                $this->assertSame( 0, $count );
     225
     226                $count = bbp_update_forum_reply_count( $f );
     227                $this->assertSame( 4, $count );
     228
     229                bbp_spam_topic( $t[2] );
     230
     231                $count = bbp_get_forum_topic_count( $f, true, true );
     232                $this->assertSame( 2, $count );
     233
     234                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     235                $this->assertSame( 1, $count );
     236
     237                $count = bbp_get_forum_reply_count( $f, true, true );
     238                $this->assertSame( 2, $count );
     239
     240                bbp_unspam_topic( $t[2] );
     241
     242                $count = bbp_get_forum_topic_count( $f, true, true );
     243                $this->assertSame( 3, $count );
     244
     245                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     246                $this->assertSame( 0, $count );
     247
     248                $count = bbp_get_forum_reply_count( $f, true, true );
     249                $this->assertSame( 4, $count );
     250        }
     251
     252        /**
     253         * Generic function to test the counts on a approved/unapproved topic
     254         */
     255        public function test_bbp_forum_approved_unapproved_topic_counts() {
     256                $f = $this->factory->forum->create();
     257                $t = $this->factory->topic->create_many( 3, array(
     258                        'post_parent' => $f,
     259                        'topic_meta' => array(
     260                                'forum_id' => $f,
     261                        ),
     262                ) );
     263                $r1 = $this->factory->reply->create_many( 2, array(
     264                        'post_parent' => $t[1],
     265                        'reply_meta' => array(
     266                                'forum_id' => $f,
     267                                'topic_id' => $t[1],
     268                        ),
     269                ) );
     270                $r2 = $this->factory->reply->create_many( 2, array(
     271                        'post_parent' => $t[2],
     272                        'reply_meta' => array(
     273                                'forum_id' => $f,
     274                                'topic_id' => $t[2],
     275                        ),
     276                ) );
     277
     278                bbp_clean_post_cache( $f );
     279
     280                $count = bbp_update_forum_topic_count( $f );
     281                $this->assertSame( 3, $count );
     282
     283                $count = bbp_update_forum_topic_count_hidden( $f );
     284                $this->assertSame( 0, $count );
     285
     286                $count = bbp_update_forum_reply_count( $f );
     287                $this->assertSame( 4, $count );
     288
     289                bbp_clean_post_cache( $t[2] );
     290                bbp_unapprove_topic( $t[2] );
     291
     292                $count = bbp_get_forum_topic_count( $f, true, true );
     293                $this->assertSame( 2, $count );
     294
     295                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     296                $this->assertSame( 1, $count );
     297
     298                $count = bbp_get_forum_reply_count( $f, true, true );
     299                $this->assertSame( 2, $count );
     300
     301                bbp_approve_topic( $t[2] );
     302
     303                $count = bbp_get_forum_topic_count( $f, true, true );
     304                $this->assertSame( 3, $count );
     305
     306                $count = bbp_get_forum_topic_count_hidden( $f, true, true );
     307                $this->assertSame( 0, $count );
     308
     309                $count = bbp_get_forum_reply_count( $f, true, true );
     310                $this->assertSame( 4, $count );
     311        }
     312
     313        public function test_bbp_move_topic_counts() {
     314                $f  = $this->factory->forum->create_many( 2 );
     315                $t1 = $this->factory->topic->create( array(
     316                        'post_parent' => $f[0],
     317                        'topic_meta' => array(
     318                                'forum_id' => $f[0],
     319                        ),
     320                ) );
     321                $t2 = $this->factory->topic->create_many( 2, array(
     322                        'post_parent' => $f[1],
     323                        'topic_meta' => array(
     324                                'forum_id' => $f[1],
     325                        ),
     326                ) );
     327                $r1 = $this->factory->reply->create_many( 2, array(
     328                        'post_parent' => $t2[0],
     329                        'reply_meta' => array(
     330                                'forum_id' => $f[1],
     331                                'topic_id' => $t2[0],
     332                        ),
     333                ) );
     334                $r2 = $this->factory->reply->create_many( 2, array(
     335                        'post_parent' => $t2[1],
     336                        'reply_meta' => array(
     337                                'forum_id' => $f[1],
     338                                'topic_id' => $t2[1],
     339                        ),
     340                ) );
     341
     342                bbp_clean_post_cache( $f[0] );
     343                bbp_clean_post_cache( $f[1] );
     344
     345                $count = bbp_update_forum_topic_count( $f[0] );
     346                $this->assertSame( 1, $count );
     347
     348                $count = bbp_update_forum_topic_count_hidden( $f[0] );
     349                $this->assertSame( 0, $count );
     350
     351                $count = bbp_update_forum_reply_count( $f[0] );
     352                $this->assertSame( 0, $count );
     353
     354                $count = bbp_update_forum_topic_count( $f[1] );
     355                $this->assertSame( 2, $count );
     356
     357                $count = bbp_update_forum_topic_count_hidden( $f[1] );
     358                $this->assertSame( 0, $count );
     359
     360                $count = bbp_update_forum_reply_count( $f[1] );
     361                $this->assertSame( 4, $count );
     362
     363                wp_update_post( array(
     364                        'ID'          => $t2[0],
     365                        'post_parent' => $f[0],
     366                ) );
     367
     368                bbp_move_topic_handler( $t2[0], $f[1], $f[0] );
     369
     370                $count = bbp_get_forum_topic_count( $f[0], true, true );
     371                $this->assertSame( 2, $count );
     372
     373                $count = bbp_get_forum_topic_count_hidden( $f[0], true, true );
     374                $this->assertSame( 0, $count );
     375
     376                $count = bbp_get_forum_reply_count( $f[0], true, true );
     377                $this->assertSame( 2, $count );
     378
     379                $count = bbp_get_forum_topic_count( $f[1], true, true );
     380                $this->assertSame( 1, $count );
     381
     382                $count = bbp_get_forum_topic_count_hidden( $f[1], true, true );
     383                $this->assertSame( 0, $count );
     384
     385                $count = bbp_get_forum_reply_count( $f[1], true, true );
     386                $this->assertSame( 2, $count );
     387        }
     388
     389        /**
    13390         * @covers ::bbp_bump_forum_topic_count
    14391         */
    15392        public function test_bbp_bump_forum_topic_count() {
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    60437        public function test_bbp_update_forum_subforum_count() {
    61438                $f1 = $this->factory->forum->create();
    62439
    63                 $f2 = $this->factory->forum->create_many( 9, array(
     440                $f2 = $this->factory->forum->create_many( 3, array(
    64441                        'post_parent' => $f1,
    65442                ) );
    66443
    67                 $count = bbp_get_forum_subforum_count( $f1, $integer = true );
     444                $count = bbp_get_forum_subforum_count( $f1, true );
    68445                $this->assertSame( 0, $count );
    69446
    70                 $count = count( bbp_forum_query_subforum_ids( $f1 ) );
    71                 $this->assertSame( 9, $count );
    72 
    73447                bbp_update_forum_subforum_count( $f1 );
    74448
    75                 $count = bbp_get_forum_subforum_count( $f1, $integer = true );
    76                 $this->assertSame( 9, $count );
    77 
    78                 $count = count( bbp_forum_query_subforum_ids( $f1 ) );
    79                 $this->assertSame( 9, $count );
     449                $count = bbp_get_forum_subforum_count( $f1, true );
     450                $this->assertSame( 3, $count );
    80451        }
    81452
    82453        /**
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    111482                        'post_parent' => $f1,
    112483                ) );
    113484
    114                 bbp_update_forum_subforum_count( $f1 );
     485                bbp_update_forum_topic_count( $f1 );
     486                bbp_update_forum_topic_count( $f2 );
     487                bbp_update_forum_topic_count( $f3 );
    115488
    116489                $count = bbp_get_forum_topic_count( $f1 );
    117490                $this->assertSame( '3', $count );
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    127500                        'post_parent' => $f2,
    128501                ) );
    129502
     503                bbp_clean_post_cache( $f1 );
     504                bbp_clean_post_cache( $f2 );
     505                bbp_clean_post_cache( $f3 );
     506
     507                bbp_update_forum_topic_count( $f1 );
    130508                bbp_update_forum_topic_count( $f2 );
     509                bbp_update_forum_topic_count( $f3 );
    131510
    132511                $count = bbp_get_forum_topic_count( $f1 );
    133                 $this->assertSame( '3', $count );
     512                $this->assertSame( '7', $count );
    134513
    135514                $count = bbp_get_forum_topic_count( $f2 );
    136515                $this->assertSame( '4', $count );
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    143522                        'post_parent' => $f3,
    144523                ) );
    145524
     525                bbp_clean_post_cache( $f1 );
     526                bbp_clean_post_cache( $f2 );
     527                bbp_clean_post_cache( $f3 );
     528
     529                bbp_update_forum_topic_count( $f1 );
     530                bbp_update_forum_topic_count( $f2 );
    146531                bbp_update_forum_topic_count( $f3 );
    147532
    148533                $count = bbp_get_forum_topic_count( $f1 );
    149                 $this->assertSame( '3', $count );
     534                $this->assertSame( '12', $count );
    150535
    151536                $count = bbp_get_forum_topic_count( $f2 );
    152537                $this->assertSame( '4', $count );
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    164549                $count = bbp_get_forum_topic_count( $f );
    165550                $this->assertSame( '0', $count );
    166551
    167                 $t = $this->factory->topic->create_many( 15, array(
     552                $t = $this->factory->topic->create_many( 3, array(
    168553                        'post_parent' => $f,
    169554                ) );
    170555
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    173558                $count = bbp_get_forum_topic_count_hidden( $f );
    174559                $this->assertSame( '0', $count );;
    175560
    176                 bbp_spam_topic( $t[11] );
     561                bbp_spam_topic( $t[2] );
    177562
    178563                bbp_update_forum_topic_count_hidden( $f );
    179564
    180565                $count = bbp_get_forum_topic_count_hidden( $f );
    181566                $this->assertSame( '1', $count );;
    182567
    183                 bbp_unapprove_topic( $t[7] );
     568                bbp_unapprove_topic( $t[0] );
    184569
    185570                bbp_update_forum_topic_count_hidden( $f );
    186571
    … … class BBP_Tests_Forums_Functions_Counts extends BBP_UnitTestCase { 
    192577         * @covers ::bbp_update_forum_reply_count
    193578         */
    194579        public function test_bbp_update_forum_reply_count() {
    195                 $f = $this->factory->forum->create();
     580                $f1 = $this->factory->forum->create();
    196581
    197                 $count = bbp_get_forum_reply_count( $f );
    198                 $this->assertSame( '0', $count );
     582                $f2 = $this->factory->forum->create( array(
     583                        'post_parent' => $f1,
     584                ) );
    199585
    200                 $t = $this->factory->topic->create( array(
    201                         'post_parent' => $f,
     586                $t1 = $this->factory->topic->create( array(
     587                        'post_parent' => $f1,
    202588                ) );
    203589
    204                 bbp_update_forum_reply_count( $f );
     590                $t2 = $this->factory->topic->create( array(
     591                        'post_parent' => $f2,
     592                ) );
    205593
    206                 $count = bbp_get_forum_reply_count( $f );
     594                $count = bbp_get_forum_reply_count( $f1 );
    207595                $this->assertSame( '0', $count );
    208596
    209                 $r = $this->factory->reply->create_many( 15, array(
    210                         'post_parent' => $t,
     597                $count = bbp_update_forum_reply_count( $f1 );
     598                $this->assertSame( 0, $count );
     599
     600                $this->factory->reply->create_many( 3, array(
     601                        'post_parent' => $t1,
    211602                ) );
    212603
    213                 bbp_update_forum_reply_count( $f );
     604                $count = bbp_update_forum_reply_count( $f1 );
     605                $this->assertSame( 3, $count );
    214606
    215                 $count = bbp_get_forum_reply_count( $f );
    216                 $this->assertSame( '15', $count );
     607                $this->factory->reply->create_many( 3, array(
     608                        'post_parent' => $t2,
     609                ) );
     610
     611                $count = bbp_update_forum_reply_count( $f1 );
     612                $this->assertSame( 6, $count );
     613
     614                $count = bbp_update_forum_reply_count( $f2 );
     615                $this->assertSame( 3, $count );
    217616        }
    218617}

  • tests/phpunit/testcases/forums/functions/query.php 

    diff --git tests/phpunit/testcases/forums/functions/query.php tests/phpunit/testcases/forums/functions/query.php
index 2dca836..f180658 100644
    class BBP_Tests_Forums_Functions_Query extends BBP_UnitTestCase { 
    3030                        'post_parent' => $f,
    3131                ) );
    3232
    33                 bbp_update_forum_topic_count( $f );
     33                $count = count( bbp_forum_query_topic_ids( $f ) );
     34                $this->assertSame( 9, $count );
     35
     36                $this->factory->topic->create_many( 9, array(
     37                        'post_parent' => $f,
     38                ) );
    3439
     40                // Test that previous value was cached
    3541                $count = count( bbp_forum_query_topic_ids( $f ) );
    36                 $this->assertSame( 9, $count );;
     42                $this->assertSame( 9, $count );
     43
     44                // Test with a fresh count
     45                wp_cache_flush();
     46                $count = count( bbp_forum_query_topic_ids( $f, true ) );
     47                $this->assertSame( 18, $count );
    3748        }
    3849
    3950        /**
    … … class BBP_Tests_Forums_Functions_Query extends BBP_UnitTestCase { 
    4758                ) );
    4859
    4960                $count = count( bbp_forum_query_subforum_ids( $f1 ) );
    50                 $this->assertSame( 9, $count );;
     61                $this->assertSame( 9, $count );
     62
     63                $f3 = $this->factory->forum->create_many( 9, array(
     64                        'post_parent' => $f1,
     65                ) );
     66
     67                // Test that previous value was cached
     68                $count = count( bbp_forum_query_subforum_ids( $f1 ) );
     69                $this->assertSame( 9, $count );
     70
     71                // Test with a fresh count
     72                wp_cache_flush();
     73                $count = count( bbp_forum_query_subforum_ids( $f1, true ) );
     74                $this->assertSame( 18, $count );
    5175        }
    5276
    5377        /**

  • tests/phpunit/testcases/forums/template/counts.php 

    diff --git tests/phpunit/testcases/forums/template/counts.php tests/phpunit/testcases/forums/template/counts.php
index 16a018f..0a35dde 100644
    class BBP_Tests_Forums_Template_Counts extends BBP_UnitTestCase { 
    1515         */
    1616        public function test_bbp_get_forum_subforum_count() {
    1717                $f1 = $this->factory->forum->create();
    18                 $int_value = 9;
     18                $int_value = 3;
    1919                $formatted_value = bbp_number_format( $int_value );
    2020
    2121                $this->factory->forum->create_many( $int_value, array(
    … … class BBP_Tests_Forums_Template_Counts extends BBP_UnitTestCase { 
    4848         */
    4949        public function test_bbp_get_forum_topic_count() {
    5050                $f = $this->factory->forum->create();
    51                 $int_value = 9;
     51                $int_value = 3;
    5252                $formatted_value = bbp_number_format( $int_value );
    5353
    5454                $this->factory->topic->create_many( $int_value, array(
    … … class BBP_Tests_Forums_Template_Counts extends BBP_UnitTestCase { 
    8181                        'post_parent' => $f
    8282                ) );
    8383
    84                 $int_value = 9;
     84                $int_value = 3;
    8585                $formatted_value = bbp_number_format( $int_value );
    8686
    8787                $this->factory->reply->create_many( $int_value, array(
    … … class BBP_Tests_Forums_Template_Counts extends BBP_UnitTestCase { 
    114114                        'post_parent' => $f
    115115                ) );
    116116
    117                 $int_value = 9;
     117                $int_value = 3;
    118118
    119119                // Topic + Replies
    120                 $result = 10;
     120                $result = 4;
    121121                $formatted_result = bbp_number_format( $result );
    122122
    123123                $this->factory->reply->create_many( $int_value, array(
    … … class BBP_Tests_Forums_Template_Counts extends BBP_UnitTestCase { 
    147147         */
    148148        public function test_bbp_get_forum_topic_count_hidden() {
    149149                $f = $this->factory->forum->create();
    150                 $int_value = 9;
     150                $int_value = 3;
    151151                $formatted_value = bbp_number_format( $int_value );
    152152
    153153                $this->factory->topic->create_many( $int_value, array(

  • tests/phpunit/testcases/topics/functions/counts.php 

    diff --git tests/phpunit/testcases/topics/functions/counts.php tests/phpunit/testcases/topics/functions/counts.php
index 1ba566c..1363386 100644
     
    1010class BBP_Tests_Topics_Functions_Counts extends BBP_UnitTestCase {
    1111
    1212        /**
     13         * Generic function to test the counts on a new reply
     14         */
     15        public function test_bbp_topic_new_reply_counts() {
     16                $f = $this->factory->forum->create();
     17                $t = $this->factory->topic->create( array(
     18                        'post_parent' => $f,
     19                        'post_author' => bbp_get_current_user_id(),
     20                        'topic_meta' => array(
     21                                'forum_id' => $f,
     22                        ),
     23                ) );
     24                $r1 = $this->factory->reply->create( array(
     25                        'post_parent' => $t,
     26                        'post_author' => bbp_get_current_user_id(),
     27                        'reply_meta' => array(
     28                                'forum_id' => $f,
     29                                'topic_id' => $t,
     30                        ),
     31                ) );
     32                $u = $this->factory->user->create();
     33
     34                // Cheating here, but we need $_SERVER['SERVER_NAME'] to be set
     35                $this->setUp_wp_mail( false );
     36
     37                // Simulate the 'bbp_new_reply' action
     38                do_action( 'bbp_new_reply', $r1, $t, $f, false, bbp_get_current_user_id() );
     39
     40                // Reverse our changes
     41                $this->tearDown_wp_mail( false );
     42
     43                $count = bbp_get_topic_reply_count( $t, true );
     44                $this->assertSame( 1, $count );
     45
     46                $count = bbp_get_topic_reply_count_hidden( $t, true );
     47                $this->assertSame( 0, $count );
     48
     49                $count = bbp_get_topic_voice_count( $t, true );
     50                $this->assertSame( 1, $count );
     51
     52                $r2 = $this->factory->reply->create( array(
     53                        'post_parent' => $t,
     54                        'post_author' => $u,
     55                        'reply_meta' => array(
     56                                'forum_id' => $f,
     57                                'topic_id' => $t,
     58                        ),
     59                ) );
     60
     61                bbp_clean_post_cache( $r2 );
     62
     63                // Cheating here, but we need $_SERVER['SERVER_NAME'] to be set
     64                $this->setUp_wp_mail( false );
     65
     66                // Simulate the 'bbp_new_topic' action
     67                do_action( 'bbp_new_reply', $r2, $t, $f, false, $u );
     68
     69                // Reverse our changes
     70                $this->tearDown_wp_mail( false );
     71
     72                $count = bbp_get_topic_reply_count( $t, true );
     73                $this->assertSame( 2, $count );
     74
     75                $count = bbp_get_topic_reply_count_hidden( $t, true );
     76                $this->assertSame( 0, $count );
     77
     78                $count = bbp_get_topic_voice_count( $t, true );
     79                $this->assertSame( 2, $count );
     80        }
     81
     82        /**
     83         * Generic function to test the counts on a deleted reply
     84         */
     85        public function test_bbp_topic_deleted_reply_counts() {
     86                $f = $this->factory->forum->create();
     87                $t = $this->factory->topic->create( array(
     88                        'post_parent' => $f,
     89                        'post_author' => bbp_get_current_user_id(),
     90                        'topic_meta' => array(
     91                                'forum_id' => $f,
     92                        ),
     93                ) );
     94                $r1 = $this->factory->reply->create( array(
     95                        'post_parent' => $t,
     96                        'post_author' => bbp_get_current_user_id(),
     97                        'reply_meta' => array(
     98                                'forum_id' => $f,
     99                                'topic_id' => $t,
     100                        ),
     101                ) );
     102                $u = $this->factory->user->create();
     103
     104                bbp_clean_post_cache( $r1 );
     105
     106                $count = bbp_update_topic_reply_count( $t );
     107                $this->assertSame( 1, $count );
     108
     109                $count = bbp_update_topic_reply_count_hidden( $t );
     110                $this->assertSame( 0, $count );
     111
     112                $count = bbp_update_topic_voice_count( $t );
     113                $this->assertSame( 1, $count );
     114
     115                $r2 = $this->factory->reply->create( array(
     116                        'post_parent' => $t,
     117                        'post_author' => $u,
     118                        'reply_meta' => array(
     119                                'forum_id' => $f,
     120                                'topic_id' => $t,
     121                        ),
     122                ) );
     123
     124                bbp_clean_post_cache( $r2 );
     125
     126                $count = bbp_update_topic_reply_count( $t );
     127                $this->assertSame( 2, $count );
     128
     129                $count = bbp_update_topic_reply_count_hidden( $t );
     130                $this->assertSame( 0, $count );
     131
     132                $count = bbp_update_topic_voice_count( $t );
     133                $this->assertSame( 2, $count );
     134
     135                bbp_clean_post_cache( $r2 );
     136                wp_delete_post( $r2, true );
     137
     138                $count = bbp_get_topic_reply_count( $t, true );
     139                $this->assertSame( 1, $count );
     140
     141                $count = bbp_get_topic_reply_count_hidden( $t, true );
     142                $this->assertSame( 0, $count );
     143
     144                $count = bbp_get_topic_voice_count( $t, true );
     145                $this->assertSame( 1, $count );
     146        }
     147
     148        /**
     149         * Generic function to test the counts on a trashed/untrashed topic
     150         */
     151        public function test_bbp_topic_trashed_untrashed_reply_counts() {
     152                $u = $this->factory->user->create();
     153                $f = $this->factory->forum->create();
     154                $t = $this->factory->topic->create( array(
     155                        'post_parent' => $f,
     156                        'topic_meta' => array(
     157                                'forum_id' => $f,
     158                        ),
     159                ) );
     160                $r = $this->factory->reply->create_many( 2, array(
     161                        'post_parent' => $t,
     162                        'reply_meta' => array(
     163                                'forum_id' => $f,
     164                                'topic_id' => $t,
     165                        ),
     166                ) );
     167                $r3 = $this->factory->reply->create( array(
     168                        'post_parent' => $t,
     169                        'post_author' => $u,
     170                        'reply_meta' => array(
     171                                'forum_id' => $f,
     172                                'topic_id' => $t,
     173                        ),
     174                ) );
     175
     176
     177                bbp_clean_post_cache( $t );
     178
     179                $count = bbp_update_topic_reply_count( $t );
     180                $this->assertSame( 3, $count );
     181
     182                $count = bbp_update_topic_reply_count_hidden( $t );
     183                $this->assertSame( 0, $count );
     184
     185                $count = bbp_update_topic_voice_count( $t );
     186                $this->assertSame( 2, $count );
     187
     188                bbp_clean_post_cache( $r3 );
     189                wp_trash_post( $r3 );
     190
     191                $count = bbp_get_topic_reply_count( $t, true );
     192                $this->assertSame( 2, $count );
     193
     194                $count = bbp_get_topic_reply_count_hidden( $t, true );
     195                $this->assertSame( 1, $count );
     196
     197                $count = bbp_get_topic_voice_count( $t, true );
     198                $this->assertSame( 1, $count );
     199
     200                bbp_clean_post_cache( $r3 );
     201                wp_untrash_post( $r3 );
     202
     203                $count = bbp_get_topic_reply_count( $t, true );
     204                $this->assertSame( 3, $count );
     205
     206                $count = bbp_get_topic_reply_count_hidden( $t, true );
     207                $this->assertSame( 0, $count );
     208
     209                $count = bbp_get_topic_voice_count( $t, true );
     210                $this->assertSame( 2, $count );
     211        }
     212
     213        /**
     214         * Generic function to test the counts on a spammed/unspammed topic
     215         */
     216        public function test_bbp_topic_spammed_unspammed_reply_counts() {
     217                $u = $this->factory->user->create();
     218                $f = $this->factory->forum->create();
     219                $t = $this->factory->topic->create( array(
     220                        'post_parent' => $f,
     221                        'topic_meta' => array(
     222                                'forum_id' => $f,
     223                        ),
     224                ) );
     225                $r = $this->factory->reply->create_many( 2, array(
     226                        'post_parent' => $t,
     227                        'reply_meta' => array(
     228                                'forum_id' => $f,
     229                                'topic_id' => $t,
     230                        ),
     231                ) );
     232                $r3 = $this->factory->reply->create( array(
     233                        'post_parent' => $t,
     234                        'post_author' => $u,
     235                        'reply_meta' => array(
     236                                'forum_id' => $f,
     237                                'topic_id' => $t,
     238                        ),
     239                ) );
     240
     241                bbp_clean_post_cache( $t );
     242
     243                $count = bbp_update_topic_reply_count( $t );
     244                $this->assertSame( 3, $count );
     245
     246                $count = bbp_update_topic_reply_count_hidden( $t );
     247                $this->assertSame( 0, $count );
     248
     249                $count = bbp_update_topic_voice_count( $t );
     250                $this->assertSame( 2, $count );
     251
     252                bbp_clean_post_cache( $r3 );
     253                bbp_spam_reply( $r3 );
     254
     255                $count = bbp_get_topic_reply_count( $t, true );
     256                $this->assertSame( 2, $count );
     257
     258                $count = bbp_get_topic_reply_count_hidden( $t, true );
     259                $this->assertSame( 1, $count );
     260
     261                $count = bbp_get_topic_voice_count( $t, true );
     262                $this->assertSame( 1, $count );
     263
     264                bbp_clean_post_cache( $r3 );
     265                bbp_unspam_reply( $r3 );
     266
     267                $count = bbp_get_topic_reply_count( $t, true );
     268                $this->assertSame( 3, $count );
     269
     270                $count = bbp_get_topic_reply_count_hidden( $t, true );
     271                $this->assertSame( 0, $count );
     272
     273                $count = bbp_get_topic_voice_count( $t, true );
     274                $this->assertSame( 2, $count );
     275        }
     276
     277        /**
     278         * Generic function to test the counts on a approved/unapproved topic
     279         */
     280        public function test_bbp_topic_approved_unapproved_reply_counts() {
     281                $u = $this->factory->user->create();
     282                $f = $this->factory->forum->create();
     283                $t = $this->factory->topic->create( array(
     284                        'post_parent' => $f,
     285                        'topic_meta' => array(
     286                                'forum_id' => $f,
     287                        ),
     288                ) );
     289                $r = $this->factory->reply->create_many( 2, array(
     290                        'post_parent' => $t,
     291                        'reply_meta' => array(
     292                                'forum_id' => $f,
     293                                'topic_id' => $t,
     294                        ),
     295                ) );
     296                $r3 = $this->factory->reply->create( array(
     297                        'post_parent' => $t,
     298                        'post_author' => $u,
     299                        'reply_meta' => array(
     300                                'forum_id' => $f,
     301                                'topic_id' => $t,
     302                        ),
     303                ) );
     304
     305                bbp_clean_post_cache( $t );
     306
     307                $count = bbp_update_topic_reply_count( $t );
     308                $this->assertSame( 3, $count );
     309
     310                $count = bbp_update_topic_reply_count_hidden( $t );
     311                $this->assertSame( 0, $count );
     312
     313                $count = bbp_update_topic_voice_count( $t );
     314                $this->assertSame( 2, $count );
     315
     316                bbp_clean_post_cache( $r3 );
     317                bbp_unapprove_reply( $r3 );
     318
     319                $count = bbp_get_topic_reply_count( $t, true );
     320                $this->assertSame( 2, $count );
     321
     322                $count = bbp_get_topic_reply_count_hidden( $t, true );
     323                $this->assertSame( 1, $count );
     324
     325                $count = bbp_get_topic_voice_count( $t, true );
     326                $this->assertSame( 1, $count );
     327
     328                bbp_clean_post_cache( $r3 );
     329                bbp_approve_reply( $r3 );
     330
     331                $count = bbp_get_topic_reply_count( $t, true );
     332                $this->assertSame( 3, $count );
     333
     334                $count = bbp_get_topic_reply_count_hidden( $t, true );
     335                $this->assertSame( 0, $count );
     336
     337                $count = bbp_get_topic_voice_count( $t, true );
     338                $this->assertSame( 2, $count );
     339        }
     340
     341        /**
    13342         * @covers ::bbp_bump_topic_reply_count
    14343         */
    15344        public function test_bbp_bump_topic_reply_count() {
    … … class BBP_Tests_Topics_Functions_Counts extends BBP_UnitTestCase { 
    18347                $count = bbp_get_topic_reply_count( $t );
    19348                $this->assertSame( '0', $count );
    20349
    21                 bbp_bump_topic_reply_count( $t );
     350                $count = bbp_bump_topic_reply_count( $t );
     351                $this->assertSame( 1, $count );
    22352
    23                 $count = bbp_get_topic_reply_count( $t );
    24                 $this->assertSame( '1', $count );
     353                $count = bbp_bump_topic_reply_count( $t, 3 );
     354                $this->assertSame( 4, $count );
     355
     356                $count = bbp_bump_topic_reply_count( $t, '1' );
     357                $this->assertSame( 5, $count );
     358
     359                $count = bbp_get_topic_reply_count( $t, true );
     360                $this->assertSame( 5, $count );
    25361        }
    26362
    27363        /**
    … … class BBP_Tests_Topics_Functions_Counts extends BBP_UnitTestCase { 
    33369                $count = bbp_get_topic_reply_count_hidden( $t );
    34370                $this->assertSame( '0', $count );
    35371
    36                 bbp_bump_topic_reply_count_hidden( $t );
     372                $count = bbp_bump_topic_reply_count_hidden( $t );
     373                $this->assertSame( 1, $count );
    37374
    38                 $count = bbp_get_topic_reply_count_hidden( $t );
    39                 $this->assertSame( '1', $count );
     375                $count = bbp_bump_topic_reply_count_hidden( $t, 3 );
     376                $this->assertSame( 4, $count );
     377
     378                $count = bbp_bump_topic_reply_count_hidden( $t, '1' );
     379                $this->assertSame( 5, $count );
     380
     381                $count = bbp_get_topic_reply_count_hidden( $t, true );
     382                $this->assertSame( 5, $count );
    40383        }
    41384
    42385        /**
    … … class BBP_Tests_Topics_Functions_Counts extends BBP_UnitTestCase { 
    66409                        )
    67410                ) );
    68411
    69                 // @todo Investigate caching issues in bbp_get_public_child_count()
    70                 wp_cache_flush();
    71 
    72                 bbp_update_topic_reply_count( $t );
    73 
    74                 // @todo Investigate caching issues in bbp_get_public_child_count()
    75                 wp_cache_flush();
    76 
    77                 $count = bbp_get_topic_reply_count( $t );
    78                 $this->assertSame( '3', $count );
     412                bbp_clean_post_cache( $t );
     413                $count = bbp_update_topic_reply_count( $t );
     414                $this->assertSame( 3, $count );
    79415
    80416                // Create another reply
    81417                $r2 = $this->factory->reply->create( array(
    … … class BBP_Tests_Topics_Functions_Counts extends BBP_UnitTestCase { 
    87423                ) );
    88424
    89425                // Test update using reply id
    90                 bbp_update_topic_reply_count( $r2 );
     426                bbp_clean_post_cache( $t );
     427                $count = bbp_update_topic_reply_count( $r2 );
     428                $this->assertSame( 4, $count );
     429
     430                bbp_spam_reply( $r2 );
     431
     432                bbp_clean_post_cache( $r2 );
     433                $count = bbp_update_topic_reply_count( $t );
     434                $this->assertSame( 3, $count );
    91435
    92436                $count = bbp_get_topic_reply_count( $t );
    93                 $this->assertSame( '4', $count );
     437                $this->assertSame( '3', $count );
    94438        }
    95439
    96440        /**
    97441         * @covers ::bbp_update_topic_reply_count_hidden
    98442         */
    99443        public function test_bbp_update_topic_reply_count_hidden() {
    100                 $t = $this->factory->topic->create();
     444                $f = $this->factory->forum->create();
     445                $t = $this->factory->topic->create( array(
     446                        'post_parent' => $f,
     447                ) );
    101448
    102449                $count = bbp_get_topic_reply_count_hidden( $t );
    103450                $this->assertSame( '0', $count );
    104451
    105                 $r = $this->factory->reply->create_many( 15, array(
     452                $r = $this->factory->reply->create_many( 3, array(
    106453                        'post_parent' => $t,
    107454                ) );
    108455
    109                 bbp_update_topic_reply_count_hidden( $t );
     456                $count = bbp_update_topic_reply_count_hidden( $t );
     457                $this->assertSame( 0, $count );
    110458
    111                 $count = bbp_get_topic_reply_count_hidden( $t );
    112                 $this->assertSame( '0', $count );
    113 
    114                 bbp_spam_reply( $r[11] );
    115 
    116                 bbp_update_topic_reply_count_hidden( $t );
    117 
    118                 $count = bbp_get_topic_reply_count_hidden( $t );
    119                 $this->assertSame( '1', $count );
     459                bbp_spam_reply( $r[2] );
    120460
    121                 bbp_unapprove_reply( $r[7] );
     461                $count = bbp_update_topic_reply_count_hidden( $t );
     462                $this->assertSame( 1, $count );
    122463
    123                 bbp_update_topic_reply_count_hidden( $t );
     464                bbp_unapprove_reply( $r[0] );
    124465
    125                 $count = bbp_get_topic_reply_count_hidden( $t );
    126                 $this->assertSame( '2', $count );
     466                $count = bbp_update_topic_reply_count_hidden( $t );
     467                $this->assertSame( 2, $count );
    127468        }
    128469
    129470        /**
    … … class BBP_Tests_Topics_Functions_Counts extends BBP_UnitTestCase { 
    141482                        'post_parent' => $t,
    142483                ) );
    143484
    144                 bbp_update_topic_voice_count( $t );
    145 
    146                 $count = bbp_get_topic_voice_count( $t );
    147                 $this->assertSame( '2', $count );
     485                $count = bbp_update_topic_voice_count( $t );
     486                $this->assertSame( 2, $count );
    148487
    149488                $r = $this->factory->reply->create( array(
    150489                        'post_author' => $u[1],
    151490                        'post_parent' => $t,
    152491                ) );
    153492
    154                 bbp_update_topic_voice_count( $t );
    155 
    156                 $count = bbp_get_topic_voice_count( $t );
    157                 $this->assertSame( '3', $count );
     493                $count = bbp_update_topic_voice_count( $t );
     494                $this->assertSame( 3, $count );
    158495        }
    159496
    160497        /**

  • tests/phpunit/testcases/topics/template/counts.php 

    diff --git tests/phpunit/testcases/topics/template/counts.php tests/phpunit/testcases/topics/template/counts.php
index 05063ef..c0212b7 100644
    class BBP_Tests_Topics_Template_Counts extends BBP_UnitTestCase { 
    2222                        )
    2323                ) );
    2424
    25                 $int_value = 9;
     25                $int_value = 3;
    2626                $formatted_value = bbp_number_format( $int_value );
    2727
    2828                $this->factory->reply->create_many( $int_value, array(
    … … class BBP_Tests_Topics_Template_Counts extends BBP_UnitTestCase { 
    3333                        )
    3434                ) );
    3535
    36                 // @todo Investigate caching issues in bbp_get_public_child_count()
    37                 wp_cache_flush();
    38 
     36                bbp_clean_post_cache( $t );
    3937                bbp_update_topic_reply_count( $t );
    4038
    4139                // Output
    … … class BBP_Tests_Topics_Template_Counts extends BBP_UnitTestCase { 
    5957                $f = $this->factory->forum->create();
    6058
    6159                $int_topics  = 1;
    62                 $int_replies = 9;
     60                $int_replies = 3;
    6361                $int_value   = $int_topics + $int_replies;
    6462                $formatted_value = bbp_number_format( $int_value );
    6563
    … … class BBP_Tests_Topics_Template_Counts extends BBP_UnitTestCase { 
    7876                        )
    7977                ) );
    8078
    81                 // @todo Investigate caching issues in bbp_get_public_child_count()
    82                 wp_cache_flush();
    83 
     79                bbp_clean_post_cache( $t );
    8480                bbp_update_topic_reply_count( $t );
    8581
    8682                // Output
    … … class BBP_Tests_Topics_Template_Counts extends BBP_UnitTestCase { 
    10399        public function test_bbp_get_topic_reply_count_hidden() {
    104100                $f = $this->factory->forum->create();
    105101
    106                 $int_value = 9;
     102                $int_value = 3;
    107103                $formatted_value = bbp_number_format( $int_value );
    108104
    109105                $t = $this->factory->topic->create( array(
    … … class BBP_Tests_Topics_Template_Counts extends BBP_UnitTestCase { 
    124120
    125121                bbp_update_topic_reply_count_hidden( $t );
    126122
    127                 bbp_spam_reply( $r[7] );
     123                bbp_spam_reply( $r[1] );
    128124
    129125                // Output
    130126                $this->expectOutputString( $formatted_value );

  • tests/phpunit/testcases/users/functions/counts.php 

    diff --git tests/phpunit/testcases/users/functions/counts.php tests/phpunit/testcases/users/functions/counts.php
index b8a7123..488554c 100644
    class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    1414         */
    1515        function test_bbp_update_user_topic_count() {
    1616                $u = $this->factory->user->create();
    17                 $int_value = 9;
     17                $int_value = 3;
    1818
    1919                bbp_update_user_topic_count( $u, $int_value );
    2020
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    2727         */
    2828        function test_bbp_update_user_reply_count() {
    2929                $u = $this->factory->user->create();
    30                 $int_value = 9;
     30                $int_value = 3;
    3131
    3232                bbp_update_user_reply_count( $u, $int_value );
    3333
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    4141         */
    4242        function test_bbp_get_user_topic_count() {
    4343                $u = $this->factory->user->create();
    44                 $int_value = 9;
     44                $int_value = 3;
    4545                $formatted_value = bbp_number_format( $int_value );
    4646
    4747                bbp_update_user_topic_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    6262         */
    6363        function test_bbp_get_user_reply_count() {
    6464                $u = $this->factory->user->create();
    65                 $int_value = 9;
     65                $int_value = 3;
    6666                $formatted_value = bbp_number_format( $int_value );
    6767
    6868                bbp_update_user_reply_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    8383         */
    8484        function test_bbp_get_user_post_count() {
    8585                $u = $this->factory->user->create();
    86                 $int_value = 9;
     86                $int_value = 3;
    8787                $integer = true;
    8888
    8989                // Add reply count
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    116116                $has_topics = bbp_get_user_topics_started( $u );
    117117                $this->assertFalse( $has_topics );
    118118
    119                 $t = $this->factory->topic->create_many( 15, array(
     119                $t = $this->factory->topic->create_many( 3, array(
    120120                        'post_author' => $u,
    121121                ) );
    122122
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    137137                $has_replies = bbp_get_user_replies_created( $u );
    138138                $this->assertFalse( $has_replies );
    139139
    140                 $r = $this->factory->reply->create_many( 15, array(
     140                $r = $this->factory->reply->create_many( 3, array(
    141141                        'post_author' => $u,
    142142                ) );
    143143
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    153153         * @covers ::bbp_get_total_users
    154154         */
    155155        public function test_bbp_get_total_users() {
    156                 $this->factory->user->create_many( 15 );
     156                $this->factory->user->create_many( 3 );
    157157
    158158                $users = (int) bbp_get_total_users();
    159159
    160160                // 15 + 1, the + 1 is the default admin user
    161                 $this->assertSame( 16, $users );
     161                $this->assertSame( 4, $users );
    162162        }
    163163
    164164        /**
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    167167        public function test_bbp_get_user_topic_count_raw() {
    168168                $u = $this->factory->user->create();
    169169
    170                 $t = $this->factory->topic->create_many( 15, array(
     170                $t = $this->factory->topic->create_many( 3, array(
    171171                        'post_author' => $u,
    172172                ) );
    173173
    174174                $count = bbp_get_user_topic_count_raw( $u );
    175                 $this->assertSame( 15, $count );
     175                $this->assertSame( 3, $count );
    176176
    177                 $t = $this->factory->topic->create_many( 15, array(
     177                $t = $this->factory->topic->create_many( 3, array(
    178178                        'post_author' => $u,
    179179                ) );
    180180
    181181                $count = bbp_get_user_topic_count_raw( $u );
    182                 $this->assertSame( 30, $count );
     182                $this->assertSame( 6, $count );
    183183        }
    184184
    185185        /**
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    188188        public function test_bbp_get_user_reply_count_raw() {
    189189                $u = $this->factory->user->create();
    190190
    191                 $r = $this->factory->reply->create_many( 15, array(
     191                $r = $this->factory->reply->create_many( 3, array(
    192192                        'post_author' => $u,
    193193                ) );
    194194
    195195                $count = bbp_get_user_reply_count_raw( $u );
    196                 $this->assertSame( 15, $count );
     196                $this->assertSame( 3, $count );
    197197
    198                 $r = $this->factory->reply->create_many( 15, array(
     198                $r = $this->factory->reply->create_many( 3, array(
    199199                        'post_author' => $u,
    200200                ) );
    201201
    202202                $count = bbp_get_user_reply_count_raw( $u );
    203                 $this->assertSame( 30, $count );
     203                $this->assertSame( 6, $count );
    204204        }
    205205
    206206        /**
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    208208         */
    209209        public function test_bbp_bump_user_topic_count() {
    210210                $u = $this->factory->user->create();
    211                 $int_value = 9;
     211                $int_value = 3;
    212212                $integer = true;
    213213
    214214                bbp_update_user_topic_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    227227         */
    228228        public function test_bbp_bump_user_reply_count() {
    229229                $u = $this->factory->user->create();
    230                 $int_value = 9;
     230                $int_value = 3;
    231231                $integer = true;
    232232
    233233                bbp_update_user_reply_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    246246         */
    247247        public function test_bbp_increase_user_topic_count() {
    248248                $u = $this->factory->user->create();
    249                 $int_value = 9;
     249                $int_value = 3;
    250250                $integer = true;
    251251
    252252                bbp_update_user_topic_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    269269         */
    270270        public function test_bbp_increase_user_reply_count() {
    271271                $u = $this->factory->user->create();
    272                 $int_value = 9;
     272                $int_value = 3;
    273273                $integer = true;
    274274
    275275                bbp_update_user_reply_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    294294         */
    295295        public function test_bbp_decrease_user_topic_count() {
    296296                $u = $this->factory->user->create();
    297                 $int_value = 9;
     297                $int_value = 3;
    298298                $integer = true;
    299299
    300300                bbp_bump_user_topic_count( $u, $int_value );
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    325325        public function test_bbp_decrease_user_reply_count() {
    326326                $u = $this->factory->user->create();
    327327
    328                 bbp_bump_user_reply_count( $u, 15 );
     328                bbp_bump_user_reply_count( $u, 3 );
    329329
    330330                $count = bbp_get_user_reply_count( $u, true );
    331                 $this->assertSame( 15, $count );
     331                $this->assertSame( 3, $count );
    332332
    333333                $r = $this->factory->reply->create( array(
    334334                        'post_author' => $u,
    … … class BBP_Tests_Users_Functions_Counts extends BBP_UnitTestCase { 
    337337                bbp_decrease_user_reply_count( $r );
    338338
    339339                $count = bbp_get_user_reply_count( $u );
    340                 $this->assertSame( '14', $count );
     340                $this->assertSame( '2', $count );
    341341
    342342                bbp_decrease_user_reply_count( $r );
    343343
    344344                $count = bbp_get_user_reply_count( $u, true );
    345                 $this->assertSame( 13, $count );
     345                $this->assertSame( 1, $count );
    346346        }
    347347}