| Server IP : 167.235.224.122 / Your IP : 216.73.216.110 Web Server : Apache/2.4.58 (Ubuntu) System : Linux newplayground 6.8.0-136-generic #136-Ubuntu SMP PREEMPT_DYNAMIC Wed Jul 1 21:33:11 UTC 2026 aarch64 User : deploy ( 1000) PHP Version : 8.4.23 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /var/www/html/wiki/tests/phpunit/unit/includes/ |
Upload File : |
<?php
// phpcs:disable MediaWiki.Commenting.FunctionComment.ObjectTypeHintReturn
// phpcs:disable MediaWiki.Commenting.FunctionComment.ObjectTypeHintParam
/**
* Test that a factory class correctly forwards all arguments to the class it constructs. This is
* useful because sometimes a class' constructor will have more arguments added, and it's easy to
* accidentally have the factory's constructor fall out of sync.
*/
trait FactoryArgTestTrait {
/**
* @return string Name of factory class
*/
abstract protected static function getFactoryClass();
/**
* @return string Name of instance class
*/
abstract protected static function getInstanceClass();
/**
* @return int The number of arguments that the instance constructor receives but the factory
* constructor doesn't. Used for a simple argument count check. Override if this isn't zero.
*/
protected static function getExtraClassArgCount() {
return 0;
}
/**
* Override if your factory method name is different from newInstanceClassName.
*
* @return string
*/
protected function getFactoryMethodName() {
return 'new' . ( new ReflectionClass( $this->getInstanceClass() ) )->getShortName();
}
/**
* Override if $factory->$method( ...$args ) isn't the right way to create an instance, where
* $method is returned from getFactoryMethodName(), and $args is constructed by applying
* getMockValueForParam() to the factory method's parameters.
*
* @param object $factory
* @return object
*/
protected function createInstanceFromFactory( $factory ) {
$methodName = $this->getFactoryMethodName();
$methodObj = new ReflectionMethod( $factory, $methodName );
$mocks = [];
foreach ( $methodObj->getParameters() as $param ) {
$mocks[] = $this->getMockValueForParam( $param );
}
return $factory->$methodName( ...$mocks );
}
public function testConstructorArgNum() {
$factoryClass = static::getFactoryClass();
$instanceClass = static::getInstanceClass();
$factoryConstructor = new ReflectionMethod( $factoryClass, '__construct' );
$instanceConstructor = new ReflectionMethod( $instanceClass, '__construct' );
$this->assertSame(
$instanceConstructor->getNumberOfParameters() - static::getExtraClassArgCount(),
$factoryConstructor->getNumberOfParameters(),
"$instanceClass and $factoryClass constructors have an inconsistent number of " .
' parameters. Did you add a parameter to one and not the other?' );
}
/**
* Override if getMockValueForParam doesn't produce suitable values for one or more of the
* parameters to your factory constructor or create method.
*
* @param ReflectionParameter $param One of the factory constructor's arguments
* @return array Empty to not override, or an array of one element which is the value to pass
* that will allow the object to be constructed successfully
*/
protected function getOverriddenMockValueForParam( ReflectionParameter $param ) {
return [];
}
/**
* Override if this doesn't produce suitable values for one or more of the parameters to your
* factory constructor or create method.
*
* @param ReflectionParameter $param One of the factory constructor's arguments
* @return mixed A value to pass that will allow the object to be constructed successfully
*/
protected function getMockValueForParam( ReflectionParameter $param ) {
$overridden = $this->getOverriddenMockValueForParam( $param );
if ( $overridden ) {
return $overridden[0];
}
$pos = $param->getPosition();
$type = $param->getType();
if ( !$type || $type->getName() === 'string' ) {
// Optimistically assume a string is okay
return "some unlikely string $pos";
}
$type = $type->getName();
if ( $type === 'array' || $type === 'iterable' ) {
return [ "some unlikely string $pos" ];
}
if ( class_exists( $type ) || interface_exists( $type ) ) {
return $this->createMock( $type );
}
$this->fail( "Unrecognized parameter type $type" );
}
/**
* Assert that the given $instance correctly received $val as the value for parameter $name. By
* default, checks that the instance has some member whose value is the same as $val.
*
* @param object $instance
* @param string $name Name of parameter to the factory object's constructor
* @param mixed $val
*/
protected function assertInstanceReceivedParam( $instance, $name, $val ) {
foreach ( ( new ReflectionObject( $instance ) )->getProperties() as $prop ) {
$prop->setAccessible( true );
if ( $prop->getValue( $instance ) === $val ) {
$this->assertTrue( true );
return;
}
}
$this->fail( "Param $name not received by " . static::getInstanceClass() );
}
/**
* Override to return a list of constructor parameters that are not stored
* in the instance properties directly, so should not be verified with
* assertInstanceReceivedParam.
* @return string[]
*/
protected function getIgnoredParamNames() {
return [ 'hookContainer' ];
}
public function testAllArgumentsWerePassed() {
$factoryClass = static::getFactoryClass();
$factoryConstructor = new ReflectionMethod( $factoryClass, '__construct' );
$mocks = [];
foreach ( $factoryConstructor->getParameters() as $param ) {
$mocks[$param->getName()] = $this->getMockValueForParam( $param );
}
$instance =
$this->createInstanceFromFactory( new $factoryClass( ...array_values( $mocks ) ) );
foreach ( $mocks as $name => $mock ) {
if ( in_array( $name, $this->getIgnoredParamNames() ) ) {
continue;
}
$this->assertInstanceReceivedParam( $instance, $name, $mock );
}
}
}