ApiQueryTestBase.php

Go to the documentation of this file.

<?php
abstract class ApiQueryTestBase extends ApiTestCase {
 
    const PARAM_ASSERT = <<<STR
Each parameter must be an array of two elements,
first - an array of params to the API call,
and the second array - expected results as returned by the API
STR;
 
    protected function merge( /*...*/ ) {
        $request = [];
        $expected = [];
        foreach ( func_get_args() as $v ) {
            list( $req, $exp ) = $this->validateRequestExpectedPair( $v );
            $request = array_merge_recursive( $request, $req );
            $this->mergeExpected( $expected, $exp );
        }
 
        return [ $request, $expected ];
    }
 
    private function validateRequestExpectedPair( $v ) {
        $this->assertInternalType( 'array', $v, self::PARAM_ASSERT );
        $this->assertEquals( 2, count( $v ), self::PARAM_ASSERT );
        $this->assertArrayHasKey( 0, $v, self::PARAM_ASSERT );
        $this->assertArrayHasKey( 1, $v, self::PARAM_ASSERT );
        $this->assertInternalType( 'array', $v[0], self::PARAM_ASSERT );
        $this->assertInternalType( 'array', $v[1], self::PARAM_ASSERT );
 
        return $v;
    }
 
    private function mergeExpected( &$all, $item ) {
        foreach ( $item as $k => $v ) {
            if ( array_key_exists( $k, $all ) ) {
                if ( is_array( $all[$k] ) ) {
                    $this->mergeExpected( $all[$k], $v );
                } else {
                    $this->assertEquals( $all[$k], $v );
                }
            } else {
                $all[$k] = $v;
            }
        }
    }
 
    protected function check( $values, array $session = null,
        $appendModule = false, User $user = null
    ) {
        list( $req, $exp ) = $this->validateRequestExpectedPair( $values );
        if ( !array_key_exists( 'action', $req ) ) {
            $req['action'] = 'query';
        }
        foreach ( $req as &$val ) {
            if ( is_array( $val ) ) {
                $val = implode( '|', array_unique( $val ) );
            }
        }
        $result = $this->doApiRequest( $req, $session, $appendModule, $user );
        $this->assertResult( [ 'batchcomplete' => true, 'query' => $exp ], $result[0], $req );
    }
 
    protected function assertResult( $exp, $result, $message = '' ) {
        try {
            $exp = self::sanitizeResultArray( $exp );
            $result = self::sanitizeResultArray( $result );
            $this->assertEquals( $exp, $result );
        } catch ( PHPUnit_Framework_ExpectationFailedException $e ) {
            if ( is_array( $message ) ) {
                $message = http_build_query( $message );
            }
 
            // FIXME: once we migrate to phpunit 4.1+, hardcode ComparisonFailure exception use
            $compEx = 'SebastianBergmann\Comparator\ComparisonFailure';
            if ( !class_exists( $compEx ) ) {
                $compEx = 'PHPUnit_Framework_ComparisonFailure';
            }
 
            throw new PHPUnit_Framework_ExpectationFailedException(
                $e->getMessage() . "\nRequest: $message",
                new $compEx(
                    $exp,
                    $result,
                    print_r( $exp, true ),
                    print_r( $result, true ),
                    false,
                    $e->getComparisonFailure()->getMessage() . "\nRequest: $message"
                )
            );
        }
    }
 
    private static function sanitizeResultArray( $result ) {
        unset( $result['pageid'] );
        foreach ( $result as $key => $value ) {
            if ( is_array( $value ) ) {
                $result[$key] = self::sanitizeResultArray( $value );
            }
        }
 
        // Sort the result by keys, then take advantage of how array_merge will
        // renumber numeric keys while leaving others alone.
        ksort( $result );
        return array_merge( $result );
    }
}