Localisation updates from https://translatewiki.net.

[mediawiki.git] / tests / phpunit / includes / utils / BatchRowUpdateTest.php

<?php

use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\Platform\SQLPlatform;
use Wikimedia\Rdbms\SelectQueryBuilder;

/**
 * Tests for BatchRowUpdate and its components
 *
 * @group db
 *
 * @covers \BatchRowUpdate
 * @covers \BatchRowIterator
 * @covers \BatchRowWriter
 */
class BatchRowUpdateTest extends MediaWikiIntegrationTestCase {

        public function testWriterBasicFunctionality() {
                $db = $this->mockDb( [ 'update' ] );
                $writer = new BatchRowWriter( $db, 'echo_event' );

                $updates = [
                        self::mockUpdate( [ 'something' => 'changed' ] ),
                        self::mockUpdate( [ 'otherthing' => 'changed' ] ),
                        self::mockUpdate( [ 'and' => 'something', 'else' => 'changed' ] ),
                ];

                $db->expects( $this->exactly( count( $updates ) ) )
                        ->method( 'update' );

                $writer->write( $updates );
        }

        protected static function mockUpdate( array $changes ) {
                static $i = 0;
                return [
                        'primaryKey' => [ 'event_id' => $i++ ],
                        'changes' => $changes,
                ];
        }

        public function testReaderBasicIterate() {
                $batchSize = 2;
                $response = $this->genSelectResult( $batchSize, /*numRows*/ 5, static function () {
                        static $i = 0;
                        return [ 'id_field' => ++$i ];
                } );
                $db = $this->mockDbConsecutiveSelect( $response );
                $reader = new BatchRowIterator( $db, 'some_table', 'id_field', $batchSize );

                $pos = 0;
                foreach ( $reader as $rows ) {
                        $this->assertEquals( $response[$pos], $rows, "Testing row in position $pos" );
                        $pos++;
                }
                // -1 is because the final [] marks the end and isn't included
                $this->assertEquals( count( $response ) - 1, $pos );
        }

        public static function provider_readerGetPrimaryKey() {
                $row = [
                        'id_field' => 42,
                        'some_col' => 'dvorak',
                        'other_col' => 'samurai',
                ];
                return [

                        [
                                'Must return single column pk when requested',
                                [ 'id_field' => 42 ],
                                $row
                        ],

                        [
                                'Must return multiple column pks when requested',
                                [ 'id_field' => 42, 'other_col' => 'samurai' ],
                                $row
                        ],

                ];
        }

        /**
         * @dataProvider provider_readerGetPrimaryKey
         */
        public function testReaderGetPrimaryKey( $message, array $expected, array $row ) {
                $reader = new BatchRowIterator( $this->mockDb(), 'some_table', array_keys( $expected ), 8675309 );
                $this->assertEquals( $expected, $reader->extractPrimaryKeys( (object)$row ), $message );
        }

        public static function provider_readerSetFetchColumns() {
                return [

                        [
                                'Must merge primary keys into select conditions',
                                // Expected column select
                                [ 'foo', 'bar' ],
                                // primary keys
                                [ 'foo' ],
                                // setFetchColumn
                                [ 'bar' ]
                        ],

                        [
                                'Must not merge primary keys into the all columns selector',
                                // Expected column select
                                [ '*' ],
                                // primary keys
                                [ 'foo' ],
                                // setFetchColumn
                                [ '*' ],
                        ],

                        [
                                'Must not duplicate primary keys into column selector',
                                // Expected column select.
                                [ 'foo', 'bar', 'baz' ],
                                // primary keys
                                [ 'foo', 'bar', ],
                                // setFetchColumn
                                [ 'bar', 'baz' ],
                        ],
                ];
        }

        /**
         * @dataProvider provider_readerSetFetchColumns
         */
        public function testReaderSetFetchColumns(
                $message, array $columns, array $primaryKeys, array $fetchColumns
        ) {
                $db = $this->mockDb( [ 'select' ] );
                $db->expects( $this->once() )
                        ->method( 'select' )
                        // only testing second parameter of Database::select
                        ->with( [ 'some_table' ], $columns )
                        ->willReturn( new FakeResultWrapper( [] ) );

                $reader = new BatchRowIterator( $db, 'some_table', $primaryKeys, 22 );
                $reader->setFetchColumns( $fetchColumns );
                // triggers first database select
                $reader->rewind();
        }

        public static function provider_readerSelectConditions() {
                return [

                        [
                                "With single primary key must generate id > 'value'",
                                // Expected second iteration
                                [ "id_field > '3'" ],
                                // Primary key(s)
                                'id_field',
                        ],

                        [
                                'With multiple primary keys the first conditions ' .
                                        'must use >= and the final condition must use >',
                                // Expected second iteration
                                [ "id_field > '3' OR (id_field = '3' AND (foo > '103'))" ],
                                // Primary key(s)
                                [ 'id_field', 'foo' ],
                        ],

                ];
        }

        /**
         * Slightly hackish to use reflection, but asserting different parameters
         * to consecutive calls of Database::select in phpunit is error prone
         *
         * @dataProvider provider_readerSelectConditions
         */
        public function testReaderSelectConditionsMultiplePrimaryKeys(
                $message, $expectedSecondIteration, $primaryKeys, $batchSize = 3
        ) {
                $results = $this->genSelectResult( $batchSize, $batchSize * 3, static function () {
                        static $i = 0, $j = 100, $k = 1000;
                        return [ 'id_field' => ++$i, 'foo' => ++$j, 'bar' => ++$k ];
                } );
                $db = $this->mockDbConsecutiveSelect( $results );

                $conditions = [ 'bar' => 42, 'baz' => 'hai' ];
                $reader = new BatchRowIterator( $db, 'some_table', $primaryKeys, $batchSize );
                $reader->addConditions( $conditions );

                $buildConditions = new ReflectionMethod( $reader, 'buildConditions' );
                $buildConditions->setAccessible( true );

                // On first iteration only the passed conditions must be used
                $this->assertEquals( $conditions, $buildConditions->invoke( $reader ),
                        'First iteration must return only the conditions passed in addConditions' );
                $reader->rewind();

                // Second iteration must use the maximum primary key of last set
                $this->assertEquals(
                        $conditions + $expectedSecondIteration,
                        $buildConditions->invoke( $reader ),
                        $message
                );
        }

        protected function mockDbConsecutiveSelect( array $retvals ) {
                $db = $this->mockDb( [ 'select', 'newSelectQueryBuilder', 'addQuotes' ] );
                $db->method( 'newSelectQueryBuilder' )->willReturnCallback( static function () use ( $db ) {
                        return new SelectQueryBuilder( $db );
                } );
                $db->method( 'select' )
                        ->will( $this->consecutivelyReturnFromSelect( $retvals ) );
                $db->method( 'addQuotes' )
                        ->willReturnCallback( static function ( $value ) {
                                return "'$value'"; // not real quoting: doesn't matter in test
                        } );

                return $db;
        }

        protected function consecutivelyReturnFromSelect( array $results ) {
                $retvals = [];
                foreach ( $results as $rows ) {
                        // The Database::select method returns result wrapper, so we do too.
                        $retvals[] = $this->returnValue( new FakeResultWrapper( $rows ) );
                }

                return $this->onConsecutiveCalls( ...$retvals );
        }

        protected function genSelectResult( $batchSize, $numRows, $rowGenerator ) {
                $res = [];
                for ( $i = 0; $i < $numRows; $i += $batchSize ) {
                        $rows = [];
                        for ( $j = 0; $j < $batchSize && $i + $j < $numRows; $j++ ) {
                                $rows[] = (object)$rowGenerator();
                        }
                        $res[] = $rows;
                }
                $res[] = []; // termination condition requires empty result for last row
                return $res;
        }

        protected function mockDb( $methods = [] ) {
                // @TODO: mock from Database
                // FIXME: the constructor normally sets mAtomicLevels and mSrvCache, and platform
                $databaseMysql = $this->getMockBuilder( Wikimedia\Rdbms\DatabaseMySQL::class )
                        ->disableOriginalConstructor()
                        ->onlyMethods( array_merge( [ 'isOpen' ], $methods ) )
                        ->getMock();

                $reflection = new ReflectionClass( $databaseMysql );
                $reflectionProperty = $reflection->getProperty( 'platform' );
                $reflectionProperty->setAccessible( true );
                $reflectionProperty->setValue( $databaseMysql, new SQLPlatform( $databaseMysql ) );

                $databaseMysql->method( 'isOpen' )
                        ->willReturn( true );
                return $databaseMysql;
        }
}