diff options
21 files changed, 892 insertions, 61 deletions
diff --git a/composer.json b/composer.json index 58e456582c..41368ef25e 100644 --- a/composer.json +++ b/composer.json @@ -16,7 +16,21 @@ "dealerdirect/phpcodesniffer-composer-installer": "~0.6.0", "wp-coding-standards/wpcs": "~2.3.0", "phpcompatibility/phpcompatibility-wp": "^2.1.0", - "phpunit/phpunit": "^5.7 || ^6.5 || ^7.5" + "phpunit/phpunit": "^7.5" + }, + "autoload-dev": { + "files": [ + "tests/phpunit/includes/phpunit7/MockObject/Builder/NamespaceMatch.php", + "tests/phpunit/includes/phpunit7/MockObject/Builder/ParametersMatch.php", + "tests/phpunit/includes/phpunit7/MockObject/InvocationMocker.php", + "tests/phpunit/includes/phpunit7/MockObject/MockMethod.php" + ], + "exclude-from-classmap": [ + "vendor/phpunit/phpunit/src/Framework/MockObject/Builder/NamespaceMatch.php", + "vendor/phpunit/phpunit/src/Framework/MockObject/Builder/ParametersMatch.php", + "vendor/phpunit/phpunit/src/Framework/MockObject/InvocationMocker.php", + "vendor/phpunit/phpunit/src/Framework/MockObject/MockMethod.php" + ] }, "scripts": { "compat": "@php ./vendor/squizlabs/php_codesniffer/bin/phpcs --standard=phpcompat.xml.dist --report=summary,source", diff --git a/phpcs.xml.dist b/phpcs.xml.dist index 7b804d3adb..0aeda7b762 100644 --- a/phpcs.xml.dist +++ b/phpcs.xml.dist @@ -134,6 +134,7 @@ <exclude-pattern>/src/wp-includes/sodium_compat/*</exclude-pattern> <exclude-pattern>/src/wp-includes/Text/*</exclude-pattern> + <exclude-pattern>/tests/phpunit/includes/phpunit7/MockObject/*</exclude-pattern> <exclude-pattern>/tests/phpunit/includes/speed-trap-listener\.php</exclude-pattern> <!-- Test data and fixtures. --> diff --git a/tests/phpunit/includes/phpunit7/MockObject/Builder/NamespaceMatch.php b/tests/phpunit/includes/phpunit7/MockObject/Builder/NamespaceMatch.php new file mode 100644 index 0000000000..99f21e745a --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Builder/NamespaceMatch.php @@ -0,0 +1,43 @@ +<?php +/* + * This file is part of PHPUnit. + * + * This file is modified to replace the Match interface with ParametersMatch, + * to avoid parse errors due to `match` being a reserved keyword in PHP 8. + * + * When the test suite is updated for compatibility with PHPUnit 9.x, + * this override can be removed. + * + * (c) Sebastian Bergmann <sebastian@phpunit.de> + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ +namespace PHPUnit\Framework\MockObject\Builder; + +/** + * Interface for builders which can register builders with a given identification. + * + * This interface relates to Identity. + */ +interface NamespaceMatch +{ + /** + * Looks up the match builder with identification $id and returns it. + * + * @param string $id The identification of the match builder + * + * @return Match + */ + public function lookupId($id); + + /** + * Registers the match builder $builder with the identification $id. The + * builder can later be looked up using lookupId() to figure out if it + * has been invoked. + * + * @param string $id The identification of the match builder + * @param Match $builder The builder which is being registered + */ + public function registerId($id, ParametersMatch $builder); +} diff --git a/tests/phpunit/includes/phpunit7/MockObject/Builder/ParametersMatch.php b/tests/phpunit/includes/phpunit7/MockObject/Builder/ParametersMatch.php new file mode 100644 index 0000000000..327557541b --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Builder/ParametersMatch.php @@ -0,0 +1,66 @@ +<?php +/* + * This file is part of PHPUnit. + * + * This file is modified to replace the Match interface with ParametersMatch, + * to avoid parse errors due to `match` being a reserved keyword in PHP 8. + * + * When the test suite is updated for compatibility with PHPUnit 9.x, + * this override can be removed. + * + * (c) Sebastian Bergmann <sebastian@phpunit.de> + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ +namespace PHPUnit\Framework\MockObject\Builder; + +use PHPUnit\Framework\MockObject\Matcher\AnyParameters; + +/** + * Builder interface for parameter matchers. + */ +interface ParametersMatch extends Stub +{ + /** + * Defines the expectation which must occur before the current is valid. + * + * @param string $id the identification of the expectation that should + * occur before this one + * + * @return Stub + */ + public function after($id); + + /** + * Sets the parameters to match for, each parameter to this function will + * be part of match. To perform specific matches or constraints create a + * new PHPUnit\Framework\Constraint\Constraint and use it for the parameter. + * If the parameter value is not a constraint it will use the + * PHPUnit\Framework\Constraint\IsEqual for the value. + * + * Some examples: + * <code> + * // match first parameter with value 2 + * $b->with(2); + * // match first parameter with value 'smock' and second identical to 42 + * $b->with('smock', new PHPUnit\Framework\Constraint\IsEqual(42)); + * </code> + * + * @return ParametersMatch + */ + public function with(...$arguments); + + /** + * Sets a matcher which allows any kind of parameters. + * + * Some examples: + * <code> + * // match any number of parameters + * $b->withAnyParameters(); + * </code> + * + * @return AnyParameters + */ + public function withAnyParameters(); +} diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/deprecation.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/deprecation.tpl.dist new file mode 100644 index 0000000000..5bf06f52de --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/deprecation.tpl.dist @@ -0,0 +1,2 @@ + + @trigger_error({deprecation}, E_USER_DEPRECATED); diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_class.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_class.tpl.dist new file mode 100644 index 0000000000..4b68a2b2b6 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_class.tpl.dist @@ -0,0 +1,46 @@ +{prologue}{class_declaration} +{ + private $__phpunit_invocationMocker; + private $__phpunit_originalObject; + private $__phpunit_configurable = {configurable}; + private $__phpunit_returnValueGeneration = true; + +{clone}{mocked_methods} + public function expects(\PHPUnit\Framework\MockObject\Matcher\Invocation $matcher) + { + return $this->__phpunit_getInvocationMocker()->expects($matcher); + } +{method} + public function __phpunit_setOriginalObject($originalObject) + { + $this->__phpunit_originalObject = $originalObject; + } + + public function __phpunit_setReturnValueGeneration(bool $returnValueGeneration) + { + $this->__phpunit_returnValueGeneration = $returnValueGeneration; + } + + public function __phpunit_getInvocationMocker() + { + if ($this->__phpunit_invocationMocker === null) { + $this->__phpunit_invocationMocker = new \PHPUnit\Framework\MockObject\InvocationMocker($this->__phpunit_configurable, $this->__phpunit_returnValueGeneration); + } + + return $this->__phpunit_invocationMocker; + } + + public function __phpunit_hasMatchers() + { + return $this->__phpunit_getInvocationMocker()->hasMatchers(); + } + + public function __phpunit_verify(bool $unsetInvocationMocker = true) + { + $this->__phpunit_getInvocationMocker()->verify(); + + if ($unsetInvocationMocker) { + $this->__phpunit_invocationMocker = null; + } + } +}{epilogue} diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_class_method.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_class_method.tpl.dist new file mode 100644 index 0000000000..d6a036f4ce --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_class_method.tpl.dist @@ -0,0 +1,8 @@ + + public function method() + { + $any = new \PHPUnit\Framework\MockObject\Matcher\AnyInvokedCount; + $expects = $this->expects($any); + + return call_user_func_array([$expects, 'method'], func_get_args()); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_clone.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_clone.tpl.dist new file mode 100644 index 0000000000..bd846dee76 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_clone.tpl.dist @@ -0,0 +1,4 @@ + public function __clone() + { + $this->__phpunit_invocationMocker = clone $this->__phpunit_getInvocationMocker(); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_method.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_method.tpl.dist new file mode 100644 index 0000000000..3adf2f0269 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_method.tpl.dist @@ -0,0 +1,22 @@ + + {modifier} function {reference}{method_name}({arguments_decl}){return_delim}{return_type} + {{deprecation} + $__phpunit_arguments = [{arguments_call}]; + $__phpunit_count = func_num_args(); + + if ($__phpunit_count > {arguments_count}) { + $__phpunit_arguments_tmp = func_get_args(); + + for ($__phpunit_i = {arguments_count}; $__phpunit_i < $__phpunit_count; $__phpunit_i++) { + $__phpunit_arguments[] = $__phpunit_arguments_tmp[$__phpunit_i]; + } + } + + $__phpunit_result = $this->__phpunit_getInvocationMocker()->invoke( + new \PHPUnit\Framework\MockObject\Invocation\ObjectInvocation( + '{class_name}', '{method_name}', $__phpunit_arguments, '{return_type}', $this, {clone_arguments} + ) + ); + + return $__phpunit_result; + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_method_void.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_method_void.tpl.dist new file mode 100644 index 0000000000..3813fe4b9d --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_method_void.tpl.dist @@ -0,0 +1,20 @@ + + {modifier} function {reference}{method_name}({arguments_decl}){return_delim}{return_type} + {{deprecation} + $__phpunit_arguments = [{arguments_call}]; + $__phpunit_count = func_num_args(); + + if ($__phpunit_count > {arguments_count}) { + $__phpunit_arguments_tmp = func_get_args(); + + for ($__phpunit_i = {arguments_count}; $__phpunit_i < $__phpunit_count; $__phpunit_i++) { + $__phpunit_arguments[] = $__phpunit_arguments_tmp[$__phpunit_i]; + } + } + + $this->__phpunit_getInvocationMocker()->invoke( + new \PHPUnit\Framework\MockObject\Invocation\ObjectInvocation( + '{class_name}', '{method_name}', $__phpunit_arguments, '{return_type}', $this, {clone_arguments} + ) + ); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_static_method.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_static_method.tpl.dist new file mode 100644 index 0000000000..56b561b65f --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/mocked_static_method.tpl.dist @@ -0,0 +1,5 @@ + + {modifier} function {reference}{method_name}({arguments_decl}){return_delim}{return_type} + { + throw new \PHPUnit\Framework\MockObject\BadMethodCallException('Static method "{method_name}" cannot be invoked on mock object'); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/proxied_method.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/proxied_method.tpl.dist new file mode 100644 index 0000000000..4dd87cd725 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/proxied_method.tpl.dist @@ -0,0 +1,26 @@ + + {modifier} function {reference}{method_name}({arguments_decl}){return_delim}{return_type} + { + $__phpunit_arguments = [{arguments_call}]; + $__phpunit_count = func_num_args(); + + if ($__phpunit_count > {arguments_count}) { + $__phpunit_arguments_tmp = func_get_args(); + + for ($__phpunit_i = {arguments_count}; $__phpunit_i < $__phpunit_count; $__phpunit_i++) { + $__phpunit_arguments[] = $__phpunit_arguments_tmp[$__phpunit_i]; + } + } + + $__phpunit_invocation = new \PHPUnit\Framework\MockObject\Invocation\ObjectInvocation( + '{class_name}', '{method_name}', $__phpunit_arguments, '{return_type}', $this, {clone_arguments} + ); + + $__phpunit_invocation->setProxiedCall(); + + $this->__phpunit_getInvocationMocker()->invoke($__phpunit_invocation); + + unset($__phpunit_invocation); + + return call_user_func_array(array($this->__phpunit_originalObject, "{method_name}"), $__phpunit_arguments); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/proxied_method_void.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/proxied_method_void.tpl.dist new file mode 100644 index 0000000000..0d868f2527 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/proxied_method_void.tpl.dist @@ -0,0 +1,26 @@ + + {modifier} function {reference}{method_name}({arguments_decl}){return_delim}{return_type} + { + $__phpunit_arguments = [{arguments_call}]; + $__phpunit_count = func_num_args(); + + if ($__phpunit_count > {arguments_count}) { + $__phpunit_arguments_tmp = func_get_args(); + + for ($__phpunit_i = {arguments_count}; $__phpunit_i < $__phpunit_count; $__phpunit_i++) { + $__phpunit_arguments[] = $__phpunit_arguments_tmp[$__phpunit_i]; + } + } + + $__phpunit_invocation = new \PHPUnit\Framework\MockObject\Invocation\ObjectInvocation( + '{class_name}', '{method_name}', $__phpunit_arguments, '{return_type}', $this, {clone_arguments} + ); + + $__phpunit_invocation->setProxiedCall(); + + $this->__phpunit_getInvocationMocker()->invoke($__phpunit_invocation); + + unset($__phpunit_invocation); + + call_user_func_array(array($this->__phpunit_originalObject, "{method_name}"), $__phpunit_arguments); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/trait_class.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/trait_class.tpl.dist new file mode 100644 index 0000000000..4143b0f66a --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/trait_class.tpl.dist @@ -0,0 +1,4 @@ +{prologue}class {class_name} +{ + use {trait_name}; +} diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/unmocked_clone.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/unmocked_clone.tpl.dist new file mode 100644 index 0000000000..fa0e70abc2 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/unmocked_clone.tpl.dist @@ -0,0 +1,5 @@ + public function __clone() + { + $this->__phpunit_invocationMocker = clone $this->__phpunit_getInvocationMocker(); + parent::__clone(); + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/wsdl_class.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/wsdl_class.tpl.dist new file mode 100644 index 0000000000..cc69fd341c --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/wsdl_class.tpl.dist @@ -0,0 +1,7 @@ +{namespace}class {class_name} extends \SoapClient +{ + public function __construct($wsdl, array $options) + { + parent::__construct('{wsdl}', $options); + } +{methods}} diff --git a/tests/phpunit/includes/phpunit7/MockObject/Generator/wsdl_method.tpl.dist b/tests/phpunit/includes/phpunit7/MockObject/Generator/wsdl_method.tpl.dist new file mode 100644 index 0000000000..bb16e763eb --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/Generator/wsdl_method.tpl.dist @@ -0,0 +1,4 @@ + + public function {method_name}({arguments}) + { + } diff --git a/tests/phpunit/includes/phpunit7/MockObject/InvocationMocker.php b/tests/phpunit/includes/phpunit7/MockObject/InvocationMocker.php new file mode 100644 index 0000000000..3a3881e976 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/InvocationMocker.php @@ -0,0 +1,192 @@ +<?php +/* + * This file is part of PHPUnit. + * + * This file is modified to replace the Match interface with ParametersMatch, + * to avoid parse errors due to `match` being a reserved keyword in PHP 8. + * + * When the test suite is updated for compatibility with PHPUnit 9.x, + * this override can be removed. + * + * (c) Sebastian Bergmann <sebastian@phpunit.de> + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ +namespace PHPUnit\Framework\MockObject; + +use Exception; +use PHPUnit\Framework\ExpectationFailedException; +use PHPUnit\Framework\MockObject\Builder\InvocationMocker as BuilderInvocationMocker; +use PHPUnit\Framework\MockObject\Builder\ParametersMatch; +use PHPUnit\Framework\MockObject\Builder\NamespaceMatch; +use PHPUnit\Framework\MockObject\Matcher\DeferredError; +use PHPUnit\Framework\MockObject\Matcher\Invocation as MatcherInvocation; +use PHPUnit\Framework\MockObject\Stub\MatcherCollection; + +/** + * Mocker for invocations which are sent from + * MockObject objects. + * + * Keeps track of all expectations and stubs as well as registering + * identifications for builders. + */ +class InvocationMocker implements Invokable, MatcherCollection, NamespaceMatch +{ + /** + * @var MatcherInvocation[] + */ + private $matchers = []; + + /** + * @var Match[] + */ + private $builderMap = []; + + /** + * @var string[] + */ + private $configurableMethods; + + /** + * @var bool + */ + private $returnValueGeneration; + + public function __construct(array $configurableMethods, bool $returnValueGeneration) + { + $this->configurableMethods = $configurableMethods; + $this->returnValueGeneration = $returnValueGeneration; + } + + public function addMatcher(MatcherInvocation $matcher): void + { + $this->matchers[] = $matcher; + } + + public function hasMatchers() + { + foreach ($this->matchers as $matcher) { + if ($matcher->hasMatchers()) { + return true; + } + } + + return false; + } + + /** + * @return null|bool + */ + public function lookupId($id) + { + if (isset($this->builderMap[$id])) { + return $this->builderMap[$id]; + } + } + + /** + * @throws RuntimeException + */ + public function registerId($id, ParametersMatch $builder): void + { + if (isset($this->builderMap[$id])) { + throw new RuntimeException( + 'Match builder with id <' . $id . '> is already registered.' + ); + } + + $this->builderMap[$id] = $builder; + } + + /** + * @return BuilderInvocationMocker + */ + public function expects(MatcherInvocation $matcher) + { + return new BuilderInvocationMocker( + $this, + $matcher, + $this->configurableMethods + ); + } + + /** + * @throws Exception + */ + public function invoke(Invocation $invocation) + { + $exception = null; + $hasReturnValue = false; + $returnValue = null; + + foreach ($this->matchers as $match) { + try { + if ($match->matches($invocation)) { + $value = $match->invoked($invocation); + + if (!$hasReturnValue) { + $returnValue = $value; + $hasReturnValue = true; + } + } + } catch (Exception $e) { + $exception = $e; + } + } + + if ($exception !== null) { + throw $exception; + } + + if ($hasReturnValue) { + return $returnValue; + } + + if ($this->returnValueGeneration === false) { + $exception = new ExpectationFailedException( + \sprintf( + 'Return value inference disabled and no expectation set up for %s::%s()', + $invocation->getClassName(), + $invocation->getMethodName() + ) + ); + + if (\strtolower($invocation->getMethodName()) === '__tostring') { + $this->addMatcher(new DeferredError($exception)); + + return ''; + } + + throw $exception; + } + + return $invocation->generateReturnValue(); + } + + /** + * @return bool + */ + public function matches(Invocation $invocation) + { + foreach ($this->matchers as $matcher) { + if (!$matcher->matches($invocation)) { + return false; + } + } + + return true; + } + + /** + * @throws \PHPUnit\Framework\ExpectationFailedException + * + * @return bool + */ + public function verify() + { + foreach ($this->matchers as $matcher) { + $matcher->verify(); + } + } +} diff --git a/tests/phpunit/includes/phpunit7/MockObject/LICENSE b/tests/phpunit/includes/phpunit7/MockObject/LICENSE new file mode 100644 index 0000000000..46fabcbdf9 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/LICENSE @@ -0,0 +1,33 @@ +PHPUnit + +Copyright (c) 2001-2019, Sebastian Bergmann <sebastian@phpunit.de>. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + * Neither the name of Sebastian Bergmann nor the names of his + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/tests/phpunit/includes/phpunit7/MockObject/MockMethod.php b/tests/phpunit/includes/phpunit7/MockObject/MockMethod.php new file mode 100644 index 0000000000..6e08753f42 --- /dev/null +++ b/tests/phpunit/includes/phpunit7/MockObject/MockMethod.php @@ -0,0 +1,363 @@ +<?php declare(strict_types=1); +/* + * This file is part of PHPUnit. + * + * This file is modified to replace ReflectionParameter::getClass() usage, + * which is deprecated in PHP 8. + * + * When the test suite is updated for compatibility with PHPUnit 9.x, + * this override can be removed. + * + * (c) Sebastian Bergmann <sebastian@phpunit.de> + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ +namespace PHPUnit\Framework\MockObject; + +use ReflectionClass; +use ReflectionException; +use ReflectionMethod; +use Text_Template; + +final class MockMethod +{ + /** + * @var Text_Template[] + */ + private static $templates = []; + + /** + * @var string + */ + private $className; + + /** + * @var string + */ + private $methodName; + + /** + * @var bool + */ + private $cloneArguments; + + /** + * @var string string + */ + private $modifier; + + /** + * @var string + */ + private $argumentsForDeclaration; + + /** + * @var string + */ + private $argumentsForCall; + + /** + * @var string + */ + private $returnType; + + /** + * @var string + */ + private $reference; + + /** + * @var bool + */ + private $callOriginalMethod; + + /** + * @var bool + */ + private $static; + + /** + * @var ?string + */ + private $deprecation; + + /** + * @var bool + */ + private $allowsReturnNull; + + public static function fromReflection(ReflectionMethod $method, bool $callOriginalMethod, bool $cloneArguments): self + { + if ($method->isPrivate()) { + $modifier = 'private'; + } elseif ($method->isProtected()) { + $modifier = 'protected'; + } else { + $modifier = 'public'; + } + + if ($method->isStatic()) { + $modifier .= ' static'; + } + + if ($method->returnsReference()) { + $reference = '&'; + } else { + $reference = ''; + } + + if ($method->hasReturnType()) { + $returnType = $method->getReturnType()->getName(); + } else { + $returnType = ''; + } + + $docComment = $method->getDocComment(); + + if (\is_string($docComment) + && \preg_match('#\*[ \t]*+@deprecated[ \t]*+(.*?)\r?+\n[ \t]*+\*(?:[ \t]*+@|/$)#s', $docComment, $deprecation) + ) { + $deprecation = \trim(\preg_replace('#[ \t]*\r?\n[ \t]*+\*[ \t]*+#', ' ', $deprecation[1])); + } else { + $deprecation = null; + } + + return new self( + $method->getDeclaringClass()->getName(), + $method->getName(), + $cloneArguments, + $modifier, + self::getMethodParameters($method), + self::getMethodParameters($method, true), + $returnType, + $reference, + $callOriginalMethod, + $method->isStatic(), + $deprecation, + $method->hasReturnType() && $method->getReturnType()->allowsNull() + ); + } + + public static function fromName(string $fullClassName, string $methodName, bool $cloneArguments): self + { + return new self( + $fullClassName, + $methodName, + $cloneArguments, + 'public', + '', + '', + '', + '', + false, + false, + null, + false + ); + } + + public function __construct(string $className, string $methodName, bool $cloneArguments, string $modifier, string $argumentsForDeclaration, string $argumentsForCall, string $returnType, string $reference, bool $callOriginalMethod, bool $static, ?string $deprecation, bool $allowsReturnNull) + { + $this->className = $className; + $this->methodName = $methodName; + $this->cloneArguments = $cloneArguments; + $this->modifier = $modifier; + $this->argumentsForDeclaration = $argumentsForDeclaration; + $this->argumentsForCall = $argumentsForCall; + $this->returnType = $returnType; + $this->reference = $reference; + $this->callOriginalMethod = $callOriginalMethod; + $this->static = $static; + $this->deprecation = $deprecation; + $this->allowsReturnNull = $allowsReturnNull; + } + + public function getName(): string + { + return $this->methodName; + } + + /** + * @throws \ReflectionException + * @throws \PHPUnit\Framework\MockObject\RuntimeException + * @throws \InvalidArgumentException + */ + public function generateCode(): string + { + if ($this->static) { + $templateFile = 'mocked_static_method.tpl'; + } elseif ($this->returnType === 'void') { + $templateFile = \sprintf( + '%s_method_void.tpl', + $this->callOriginalMethod ? 'proxied' : 'mocked' + ); + } else { + $templateFile = \sprintf( + '%s_method.tpl', + $this->callOriginalMethod ? 'proxied' : 'mocked' + ); + } + + $returnType = $this->returnType; + // @see https://bugs.php.net/bug.php?id=70722 + if ($returnType === 'self') { + $returnType = $this->className; + } + + // @see https://github.com/sebastianbergmann/phpunit-mock-objects/issues/406 + if ($returnType === 'parent') { + $reflector = new ReflectionClass($this->className); + + $parentClass = $reflector->getParentClass(); + + if ($parentClass === false) { + throw new RuntimeException( + \sprintf( + 'Cannot mock %s::%s because "parent" return type declaration is used but %s does not have a parent class', + $this->className, + $this->methodName, + $this->className + ) + ); + } + + $returnType = $parentClass->getName(); + } + + $deprecation = $this->deprecation; + + if (null !== $this->deprecation) { + $deprecation = "The $this->className::$this->methodName method is deprecated ($this->deprecation)."; + $deprecationTemplate = $this->getTemplate('deprecation.tpl'); + + $deprecationTemplate->setVar([ + 'deprecation' => \var_export($deprecation, true), + ]); + + $deprecation = $deprecationTemplate->render(); + } + + $template = $this->getTemplate($templateFile); + + $template->setVar( + [ + 'arguments_decl' => $this->argumentsForDeclaration, + 'arguments_call' => $this->argumentsForCall, + 'return_delim' => $returnType ? ': ' : '', + 'return_type' => $this->allowsReturnNull ? '?' . $returnType : $returnType, + 'arguments_count' => !empty($this->argumentsForCall) ? \substr_count($this->argumentsForCall, ',') + 1 : 0, + 'class_name' => $this->className, + 'method_name' => $this->methodName, + 'modifier' => $this->modifier, + 'reference' => $this->reference, + 'clone_arguments' => $this->cloneArguments ? 'true' : 'false', + 'deprecation' => $deprecation, + ] + ); + + return $template->render(); + } + + private function getTemplate(string $template): Text_Template + { + $filename = __DIR__ . \DIRECTORY_SEPARATOR . 'Generator' . \DIRECTORY_SEPARATOR . $template; + + if (!isset(self::$templates[$filename])) { + self::$templates[$filename] = new Text_Template($filename); + } + + return self::$templates[$filename]; + } + + /** + * Returns the parameters of a function or method. + * + * @throws RuntimeException + */ + private static function getMethodParameters(ReflectionMethod $method, bool $forCall = false): string + { + $parameters = []; + + foreach ($method->getParameters() as $i => $parameter) { + $name = '$' . $parameter->getName(); + + /* Note: PHP extensions may use empty names for reference arguments + * or "..." for methods taking a variable number of arguments. + */ + if ($name === '$' || $name === '$...') { + $name = '$arg' . $i; + } + + if ($parameter->isVariadic()) { + if ($forCall) { + continue; + } + + $name = '...' . $name; + } + + $nullable = ''; + $default = ''; + $reference = ''; + $typeDeclaration = ''; + + if (!$forCall) { + if ($parameter->hasType() && $parameter->allowsNull()) { + $nullable = '?'; + } + + if ($parameter->hasType() && $parameter->getType()->getName() !== 'self') { + $typeDeclaration = $parameter->getType()->getName() . ' '; + } else { + try { + $class = $parameter->getType() && !$parameter->getType()->isBuiltin() + ? new ReflectionClass($parameter->getType()->getName()) + : null; + } catch (ReflectionException $e) { + throw new RuntimeException( + \sprintf( + 'Cannot mock %s::%s() because a class or ' . + 'interface used in the signature is not loaded', + $method->getDeclaringClass()->getName(), + $method->getName() + ), + 0, + $e + ); + } + + if ($class !== null) { + $typeDeclaration = $class->getName() . ' '; + } + } + + if (!$parameter->isVariadic()) { + if ($parameter->isDefaultValueAvailable()) { + try { + $value = \var_export($parameter->getDefaultValue(), true); + } catch (\ReflectionException $e) { + throw new RuntimeException( + $e->getMessage(), + (int) $e->getCode(), + $e + ); + } + + $default = ' = ' . $value; + } elseif ($parameter->isOptional()) { + $default = ' = null'; + } + } + } + + if ($parameter->isPassedByReference()) { + $reference = '&'; + } + + $parameters[] = $nullable . $typeDeclaration . $reference . $name . $default; + } + + return \implode(', ', $parameters); + } +} diff --git a/tests/phpunit/includes/phpunit7/testcase.php b/tests/phpunit/includes/phpunit7/testcase.php index 948f5799de..9a8ddc12de 100644 --- a/tests/phpunit/includes/phpunit7/testcase.php +++ b/tests/phpunit/includes/phpunit7/testcase.php @@ -37,64 +37,4 @@ class WP_UnitTestCase extends WP_UnitTestCase_Base { static::assertThat( $actual, $constraint, $message ); } - - /** - * Returns a mock object for the specified abstract class with all abstract - * methods of the class mocked. Concrete methods to mock can be specified with - * the last parameter. - * - * This method replaces the native PHPUnit method to avoid parse errors - * due to `match` being a reserved keyword in PHP 8. - * - * To run on PHP 8, the tests using this method require PHPUnit 9.3 or later. - * - * When the test suite is updated for compatibility with PHPUnit 9.x, - * this override can be removed. - * - * @since 5.6.0 - * - * @param string $original_class_name - * @param string $mock_class_name - * @param bool $call_original_constructor - * @param bool $call_original_clone - * @param bool $call_autoload - * @param array $mocked_methods - * @param bool $clone_arguments - * - * @throws \ReflectionException - * @throws RuntimeException - * @throws Exception - * - * @return MockObject - */ - public function getMockForAbstractClass( $original_class_name, array $arguments = array(), $mock_class_name = '', $call_original_constructor = true, $call_original_clone = true, $call_autoload = true, $mocked_methods = array(), $clone_arguments = false ): PHPUnit\Framework\MockObject\MockObject { - if ( PHP_VERSION_ID >= 80000 && version_compare( tests_get_phpunit_version(), '9.3', '<' ) ) { - $this->markTestSkipped( 'To run on PHP 8, this test requires PHPUnit 9.3 or later.' ); - } - - return parent::getMockForAbstractClass( $original_class_name, $arguments, $mock_class_name, $call_original_constructor, $call_original_clone, $call_autoload, $mocked_methods, $clone_arguments ); - } - - /** - * Returns a builder object to create mock objects using a fluent interface. - * - * This method replaces the native PHPUnit method to avoid parse errors - * due to `match` being a reserved keyword in PHP 8. - * - * To run on PHP 8, the tests using this method require PHPUnit 9.3 or later. - * - * When the test suite is updated for compatibility with PHPUnit 9.x, - * this override can be removed. - * - * @since 5.6.0 - * - * @param string|string[] $class_name - */ - public function getMockBuilder( $class_name ): PHPUnit\Framework\MockObject\MockBuilder { - if ( PHP_VERSION_ID >= 80000 && version_compare( tests_get_phpunit_version(), '9.3', '<' ) ) { - $this->markTestSkipped( 'To run on PHP 8, this test requires PHPUnit 9.3 or later.' ); - } - - return parent::getMockBuilder( $class_name ); - } } |