1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
<?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 );
}
}
}
|
