tests/phpunit/includes/api/query/ApiQueryUserContribsTest.php

   1 <?php
   2
   3 /**
   4  * @group API
   5  * @group Database
   6  * @group medium
   7  * @covers ApiQueryUserContribs
   8  */
   9 class ApiQueryUserContribsTest extends ApiTestCase {
  10         public function addDBDataOnce() {
  11                 $users = [
  12                         User::newFromName( '192.168.2.2', false ),
  13                         User::newFromName( '192.168.2.1', false ),
  14                         User::newFromName( '192.168.2.3', false ),
  15                         User::createNew( __CLASS__ . ' B' ),
  16                         User::createNew( __CLASS__ . ' A' ),
  17                         User::createNew( __CLASS__ . ' C' ),
  18                         User::newFromName( 'IW>' . __CLASS__, false ),
  19                 ];
  20
  21                 $title = Title::newFromText( __CLASS__ );
  22                 $page = WikiPage::factory( $title );
  23                 for ( $i = 0; $i < 3; $i++ ) {
  24                         foreach ( array_reverse( $users ) as $user ) {
  25                                 $status = $page->doEditContent(
  26                                         ContentHandler::makeContent( "Test revision $user #$i", $title ), 'Test edit', 0, false, $user
  27                                 );
  28                                 if ( !$status->isOK() ) {
  29                                         $this->fail( "Failed to edit $title: " . $status->getWikiText( false, false, 'en' ) );
  30                                 }
  31                         }
  32                 }
  33         }
  34
  35         /**
  36          * @dataProvider provideSorting
  37          * @param array $params Extra parameters for the query
  38          * @param bool $reverse Reverse order?
  39          * @param int $revs Number of revisions to expect
  40          */
  41         public function testSorting( $params, $reverse, $revs ) {
  42                 // FIXME: fails under sqlite
  43                 $this->markTestSkippedIfDbType( 'sqlite' );
  44
  45                 if ( isset( $params['ucuserids'] ) ) {
  46                         $params['ucuserids'] = implode( '|', array_map( 'User::idFromName', $params['ucuserids'] ) );
  47                 }
  48                 if ( isset( $params['ucuser'] ) ) {
  49                         $params['ucuser'] = implode( '|', $params['ucuser'] );
  50                 }
  51
  52                 $sort = 'rsort';
  53                 if ( $reverse ) {
  54                         $params['ucdir'] = 'newer';
  55                         $sort = 'sort';
  56                 }
  57
  58                 $params += [
  59                         'action' => 'query',
  60                         'list' => 'usercontribs',
  61                         'ucprop' => 'ids',
  62                 ];
  63
  64                 $apiResult = $this->doApiRequest( $params + [ 'uclimit' => 500 ] );
  65                 $this->assertArrayNotHasKey( 'continue', $apiResult[0] );
  66                 $this->assertArrayHasKey( 'query', $apiResult[0] );
  67                 $this->assertArrayHasKey( 'usercontribs', $apiResult[0]['query'] );
  68
  69                 $count = 0;
  70                 $ids = [];
  71                 foreach ( $apiResult[0]['query']['usercontribs'] as $page ) {
  72                         $count++;
  73                         $ids[$page['user']][] = $page['revid'];
  74                 }
  75                 $this->assertSame( $revs, $count, 'Expected number of revisions' );
  76                 foreach ( $ids as $user => $revids ) {
  77                         $sorted = $revids;
  78                         call_user_func_array( $sort, [ &$sorted ] );
  79                         $this->assertSame( $sorted, $revids, "IDs for $user are sorted" );
  80                 }
  81
  82                 for ( $limit = 1; $limit < $revs; $limit++ ) {
  83                         $continue = [];
  84                         $count = 0;
  85                         $batchedIds = [];
  86                         while ( $continue !== null ) {
  87                                 $apiResult = $this->doApiRequest( $params + [ 'uclimit' => $limit ] + $continue );
  88                                 $this->assertArrayHasKey( 'query', $apiResult[0], "Batching with limit $limit" );
  89                                 $this->assertArrayHasKey( 'usercontribs', $apiResult[0]['query'],
  90                                         "Batching with limit $limit" );
  91                                 $continue = $apiResult[0]['continue'] ?? null;
  92                                 foreach ( $apiResult[0]['query']['usercontribs'] as $page ) {
  93                                         $count++;
  94                                         $batchedIds[$page['user']][] = $page['revid'];
  95                                 }
  96                                 $this->assertLessThanOrEqual( $revs, $count, "Batching with limit $limit" );
  97                         }
  98                         $this->assertSame( $ids, $batchedIds, "Result set is the same when batching with limit $limit" );
  99                 }
 100         }
 101
 102         public static function provideSorting() {
 103                 $users = [ __CLASS__ . ' A', __CLASS__ . ' B', __CLASS__ . ' C' ];
 104                 $users2 = [ __CLASS__ . ' A', __CLASS__ . ' B', __CLASS__ . ' D' ];
 105                 $ips = [ '192.168.2.1', '192.168.2.2', '192.168.2.3', '192.168.2.4' ];
 106
 107                 foreach ( [ false, true ] as $reverse ) {
 108                         $name = ( $reverse ? ', reverse' : '' );
 109                         yield "Named users, $name" => [ [ 'ucuser' => $users ], $reverse, 9 ];
 110                         yield "Named users including a no-edit user, $name" => [
 111                                 [ 'ucuser' => $users2 ], $reverse, 6
 112                         ];
 113                         yield "IP users, $name" => [ [ 'ucuser' => $ips ], $reverse, 9 ];
 114                         yield "All users, $name" => [
 115                                 [ 'ucuser' => array_merge( $users, $ips ) ], $reverse, 18
 116                         ];
 117                         yield "User IDs, $name" => [ [ 'ucuserids' => $users ], $reverse, 9 ];
 118                         yield "Users by prefix, $name" => [ [ 'ucuserprefix' => __CLASS__ ], $reverse, 9 ];
 119                         yield "IPs by prefix, $name" => [ [ 'ucuserprefix' => '192.168.2.' ], $reverse, 9 ];
 120                 }
 121         }
 122
 123         public function testInterwikiUser() {
 124                 $params = [
 125                         'action' => 'query',
 126                         'list' => 'usercontribs',
 127                         'ucuser' => 'IW>' . __CLASS__,
 128                         'ucprop' => 'ids',
 129                         'uclimit' => 'max',
 130                 ];
 131
 132                 $apiResult = $this->doApiRequest( $params );
 133                 $this->assertArrayNotHasKey( 'continue', $apiResult[0] );
 134                 $this->assertArrayHasKey( 'query', $apiResult[0] );
 135                 $this->assertArrayHasKey( 'usercontribs', $apiResult[0]['query'] );
 136
 137                 $count = 0;
 138                 $ids = [];
 139                 foreach ( $apiResult[0]['query']['usercontribs'] as $page ) {
 140                         $count++;
 141                         $this->assertSame( 'IW>' . __CLASS__, $page['user'], 'Correct user returned' );
 142                         $ids[] = $page['revid'];
 143                 }
 144                 $this->assertSame( 3, $count, 'Expected number of revisions' );
 145                 $sorted = $ids;
 146                 rsort( $sorted );
 147                 $this->assertSame( $sorted, $ids, "IDs are sorted" );
 148         }
 149
 150 }