Merge "Cleaned up FileJournal documentation."

[lhc/web/wiklou.git] / tests / phpunit / MediaWikiTestCase.php

diff --git a/tests/phpunit/MediaWikiTestCase.php b/tests/phpunit/MediaWikiTestCase.php
index f626459..c873c51 100644 (file)
--- a/tests/phpunit/MediaWikiTestCase.php
+++ b/tests/phpunit/MediaWikiTestCase.php
@@ -132,8 +132,18 @@ abstract class MediaWikiTestCase extends PHPUnit_Framework_TestCase {
        }
 
        function needsDB() {
+               # if the test says it uses database tables, it needs the database
+               if ( $this->tablesUsed ) {
+                       return true;
+               }
+
+               # if the test says it belongs to the Database group, it needs the database
                $rc = new ReflectionClass( $this );
-               return strpos( $rc->getDocComment(), '@group Database' ) !== false;
+               if ( preg_match( '/@group +Database/im', $rc->getDocComment() ) ) {
+                       return true;
+               }
+
+               return false;
        }
 
        /**
@@ -316,10 +326,6 @@ abstract class MediaWikiTestCase extends PHPUnit_Framework_TestCase {
 
        }
 
-       public static function disableInterwikis( $prefix, &$data ) {
-               return false;
-       }
-
        /**
         * Don't throw a warning if $function is deprecated and called later
         *
@@ -331,4 +337,138 @@ abstract class MediaWikiTestCase extends PHPUnit_Framework_TestCase {
                wfDeprecated( $function );
                wfRestoreWarnings();
        }
+
+       /**
+        * Asserts that the given database query yields the rows given by $expectedRows.
+        * The expected rows should be given as indexed (not associative) arrays, with
+        * the values given in the order of the columns in the $fields parameter.
+        * Note that the rows are sorted by the columns given in $fields.
+        *
+        * @since 1.20
+        *
+        * @param $table String|Array the table(s) to query
+        * @param $fields String|Array the columns to include in the result (and to sort by)
+        * @param $condition String|Array "where" condition(s)
+        * @param $expectedRows Array - an array of arrays giving the expected rows.
+        *
+        * @throws MWException if this test cases's needsDB() method doesn't return true.
+        *         Test cases can use "@group Database" to enable database test support,
+        *         or list the tables under testing in $this->tablesUsed, or override the
+        *         needsDB() method.
+        */
+       protected function assertSelect( $table, $fields, $condition, Array $expectedRows ) {
+               if ( !$this->needsDB() ) {
+                       throw new MWException( 'When testing database state, the test cases\'s needDB()' .
+                               ' method should return true. Use @group Database or $this->tablesUsed.');
+               }
+
+               $db = wfGetDB( DB_SLAVE );
+
+               $res = $db->select( $table, $fields, $condition, wfGetCaller(), array( 'ORDER BY' => $fields ) );
+               $this->assertNotEmpty( $res, "query failed: " . $db->lastError() );
+
+               $i = 0;
+
+               foreach ( $expectedRows as $expected ) {
+                       $r = $res->fetchRow();
+                       self::stripStringKeys( $r );
+
+                       $i += 1;
+                       $this->assertNotEmpty( $r, "row #$i missing" );
+
+                       $this->assertEquals( $expected, $r, "row #$i mismatches" );
+               }
+
+               $r = $res->fetchRow();
+               self::stripStringKeys( $r );
+
+               $this->assertFalse( $r, "found extra row (after #$i)" );
+       }
+
+       /**
+        * Utility method taking an array of elements and wrapping
+        * each element in it's own array. Useful for data providers
+        * that only return a single argument.
+        *
+        * @since 1.20
+        *
+        * @param array $elements
+        *
+        * @return array
+        */
+       protected function arrayWrap( array $elements ) {
+               return array_map(
+                       function( $element ) {
+                               return array( $element );
+                       },
+                       $elements
+               );
+       }
+
+       /**
+        * Assert that two arrays are equal. By default this means that both arrays need to hold
+        * the same set of values. Using additional arguments, order and associated key can also
+        * be set as relevant.
+        *
+        * @since 1.20
+        *
+        * @param array $expected
+        * @param array $actual
+        * @param boolean $ordered If the order of the values should match
+        * @param boolean $named If the keys should match
+        */
+       protected function assertArrayEquals( array $expected, array $actual, $ordered = false, $named = false ) {
+               if ( !$ordered ) {
+                       $this->objectAssociativeSort( $expected );
+                       $this->objectAssociativeSort( $actual );
+               }
+
+               if ( !$named ) {
+                       $expected = array_values( $expected );
+                       $actual = array_values( $actual );
+               }
+
+               call_user_func_array(
+                       array( $this, 'assertEquals' ),
+                       array_merge( array( $expected, $actual ), array_slice( func_get_args(), 4 ) )
+               );
+       }
+
+       /**
+        * Does an associative sort that works for objects.
+        *
+        * @since 1.20
+        *
+        * @param array $array
+        */
+       protected function objectAssociativeSort( array &$array ) {
+               uasort(
+                       $array,
+                       function( $a, $b ) {
+                               return serialize( $a ) > serialize( $b ) ? 1 : -1;
+                       }
+               );
+       }
+
+       /**
+        * Utility function for eliminating all string keys from an array.
+        * Useful to turn a database result row as returned by fetchRow() into
+        * a pure indexed array.
+        *
+        * @since 1.20
+        *
+        * @param $r mixed the array to remove string keys from.
+        */
+       protected static function stripStringKeys( &$r ) {
+               if ( !is_array( $r ) ) {
+                       return;
+               }
+
+               foreach ( $r as $k => $v ) {
+                       if ( is_string( $k ) ) {
+                               unset( $r[$k] );
+                       }
+               }
+       }
+
 }