From edff82f93873ed00d9c65b5b1041c1d1b187b208 Mon Sep 17 00:00:00 2001 From: W0rma Date: Fri, 19 Dec 2025 15:09:54 +0100 Subject: [PATCH] feat: add replacements for deprecated assertContainsOnly() and assertNotContainsOnly() DEPRECATED: InheritAsserts::assertContainsOnly() and InheritAsserts::assertNotContainsOnly() use assertContainsOnlyArray(), assertContainsOnlyBool(), assertContainsOnlyCallable(), assertContainsOnlyFloat(), assertContainsOnlyInt(), assertContainsOnlyIterable(), assertContainsOnlyNumeric(), assertContainsOnlyObject(), assertContainsOnlyResource(), assertContainsOnlyClosedResource(), assertContainsOnlyScalar(), assertContainsOnlyString(), assertContainsNotOnlyArray(), assertContainsNotOnlyBool(), assertContainsNotOnlyCallable(), assertContainsNotOnlyFloat(), assertContainsNotOnlyInt(), assertContainsNotOnlyIterable(), assertContainsNotOnlyNumeric(), assertContainsNotOnlyObject(), assertContainsNotOnlyResource(), assertContainsNotOnlyClosedResource(), assertContainsNotOnlyScalar(), or assertContainsNotOnlyString() instead --- docs/supported_asserts.md | 27 ++ phpstan.neon | 9 +- .../Util/Shared/InheritedAsserts.php | 307 +++++++++++++++++- 3 files changed, 337 insertions(+), 6 deletions(-) diff --git a/docs/supported_asserts.md b/docs/supported_asserts.md index 15172b0..4ac1dae 100644 --- a/docs/supported_asserts.md +++ b/docs/supported_asserts.md @@ -20,8 +20,35 @@ assertClassNotHasAttribute assertClassNotHasStaticAttribute assertContains assertContainsEquals +assertContainsNotOnlyArray +assertContainsNotOnlyBool +assertContainsNotOnlyCallable +assertContainsNotOnlyClosedResource +assertContainsNotOnlyFloat +assertContainsNotOnlyInstancesOf +assertContainsNotOnlyInt +assertContainsNotOnlyIterable +assertContainsNotOnlyNull +assertContainsNotOnlyNumeric +assertContainsNotOnlyObject +assertContainsNotOnlyResource +assertContainsNotOnlyScalar +assertContainsNotOnlyString assertContainsOnly +assertContainsOnlyArray +assertContainsOnlyBool +assertContainsOnlyCallable +assertContainsOnlyClosedResource +assertContainsOnlyFloat assertContainsOnlyInstancesOf +assertContainsOnlyInt +assertContainsOnlyIterable +assertContainsOnlyNull +assertContainsOnlyNumeric +assertContainsOnlyObject +assertContainsOnlyResource +assertContainsOnlyScalar +assertContainsOnlyString assertCount assertDirectoryDoesNotExist assertDirectoryExists diff --git a/phpstan.neon b/phpstan.neon index c7dfed4..312d874 100644 --- a/phpstan.neon +++ b/phpstan.neon @@ -2,4 +2,11 @@ parameters: level: 9 paths: - tests/ - - src/ \ No newline at end of file + - src/ + ignoreErrors: + - + message: '#Parameter \#1 \$className of static method PHPUnit\\Framework\\Assert::assertContainsOnlyInstancesOf\(\) expects class-string, string given\.#' + path: src/Codeception/Util/Shared/InheritedAsserts.php + - + message: '#Parameter \#1 \$className of static method PHPUnit\\Framework\\Assert::assertContainsNotOnlyInstancesOf\(\) expects class-string, string given\.#' + path: src/Codeception/Util/Shared/InheritedAsserts.php \ No newline at end of file diff --git a/src/Codeception/Util/Shared/InheritedAsserts.php b/src/Codeception/Util/Shared/InheritedAsserts.php index 92ca18b..18613ac 100644 --- a/src/Codeception/Util/Shared/InheritedAsserts.php +++ b/src/Codeception/Util/Shared/InheritedAsserts.php @@ -99,14 +99,167 @@ protected function assertNotContainsEquals(mixed $needle, iterable $haystack, st Assert::assertNotContainsEquals($needle, $haystack, $message); } + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyArray(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyArray($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyBool(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyBool($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyCallable(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyCallable($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyFloat(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyFloat($haystack, $message); + } + + /** + * @param class-string $className + * @param iterable $haystack + */ + protected function assertContainsNotOnlyInstancesOf(string $className, iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyInstancesOf($className, $haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyInt(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyInt($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyIterable(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyIterable($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyNull(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyNull($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyNumeric(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyNumeric($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyObject(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyObject($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyResource(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyResource($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyClosedResource(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyClosedResource($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyScalar(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyScalar($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsNotOnlyString(iterable $haystack, string $message = ''): void + { + Assert::assertContainsNotOnlyString($haystack, $message); + } + /** * Asserts that a haystack contains only values of a given type. - * @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string' $type + * @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string'|class-string $type * @param iterable $haystack */ protected function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void { - Assert::assertContainsOnly($type, $haystack, $isNativeType, $message); + $replacement = match ($type) { + 'array' => 'assertContainsOnlyArray', + 'bool', 'boolean' => 'assertContainsOnlyBool', + 'callable' => 'assertContainsOnlyCallable', + 'double', 'float', 'real' => 'assertContainsOnlyFloat', + 'int', 'integer' => 'assertContainsOnlyInt', + 'iterable' => 'assertContainsOnlyIterable', + 'null' => 'assertContainsOnlyNull', + 'numeric' => 'assertContainsOnlyNumeric', + 'object' => 'assertContainsOnlyObject', + 'resource' => 'assertContainsOnlyResource', + 'resource (closed)' => 'assertContainsOnlyClosedResource', + 'scalar' => 'assertContainsOnlyScalar', + 'string' => 'assertContainsOnlyString', + default => null, + }; + + if (is_string($replacement)) { + trigger_error( + sprintf( + '%s is deprecated since PHPUnit 11.5. Please use %s($haystack) instead of assertContainsOnly(\'%s\', $haystack)', + __FUNCTION__, + $replacement, + $type, + ), + E_USER_DEPRECATED, + ); + + $this->$replacement($haystack, $message); + } else { + trigger_error( + sprintf( + 'assertContainsOnly() is deprecated since PHPUnit 11.5. Please use assertContainsOnlyInstancesOf(\'%s\', $haystack) instead of assertContainsOnly(\'%s\', $haystack).', + $type, + $type, + ), + E_USER_DEPRECATED, + ); + + Assert::assertContainsOnlyInstancesOf($type, $haystack, $message); + } } /** @@ -119,6 +272,110 @@ protected function assertContainsOnlyInstancesOf(string $className, iterable $ha Assert::assertContainsOnlyInstancesOf($className, $haystack, $message); } + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyArray(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyArray($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyBool(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyBool($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyCallable(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyCallable($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyFloat(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyFloat($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyInt(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyInt($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyIterable(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyIterable($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyNull(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyNull($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyNumeric(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyNumeric($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyObject(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyObject($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyResource(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyResource($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyClosedResource(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyClosedResource($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyScalar(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyScalar($haystack, $message); + } + + /** + * @param iterable $haystack + */ + protected function assertContainsOnlyString(iterable $haystack, string $message = ''): void + { + Assert::assertContainsOnlyString($haystack, $message); + } + /** * Asserts the number of elements of an array, Countable or Traversable. * @@ -833,14 +1090,54 @@ protected function assertNotContains(mixed $needle, iterable $haystack, string $ /** * Asserts that a haystack does not contain only values of a given type. - * @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string' $type + * @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string'|class-string $type * @param iterable $haystack */ protected function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void { - Assert::assertNotContainsOnly($type, $haystack, $isNativeType, $message); + $replacement = match ($type) { + 'array' => 'assertContainsNotOnlyArray', + 'bool', 'boolean' => 'assertContainsNotOnlyBool', + 'callable' => 'assertContainsNotOnlyCallable', + 'double', 'float', 'real' => 'assertContainsNotOnlyFloat', + 'int', 'integer' => 'assertContainsNotOnlyInt', + 'iterable' => 'assertContainsNotOnlyIterable', + 'null' => 'assertContainsNotOnlyNull', + 'numeric' => 'assertContainsNotOnlyNumeric', + 'object' => 'assertContainsNotOnlyObject', + 'resource' => 'assertContainsNotOnlyResource', + 'resource (closed)' => 'assertContainsNotOnlyClosedResource', + 'scalar' => 'assertContainsNotOnlyScalar', + 'string' => 'assertContainsNotOnlyString', + default => null, + }; + + if (is_string($replacement)) { + trigger_error( + sprintf( + '%s is deprecated since PHPUnit 11.5. Please use %s($haystack) instead of assertContainsNotOnly(\'%s\', $haystack)', + __FUNCTION__, + $replacement, + $type, + ), + E_USER_DEPRECATED, + ); + + $this->$replacement($haystack, $message); + } else { + trigger_error( + sprintf( + 'assertNotContainsOnly() is deprecated since PHPUnit 11.5. Please use assertContainsNotOnlyInstancesOf(\'%s\', $haystack) instead of assertNotContainsOnly(\'%s\', $haystack).', + $type, + $type, + ), + E_USER_DEPRECATED, + ); + + Assert::assertContainsNotOnlyInstancesOf($type, $haystack, $message); + } } - + /** * Asserts the number of elements of an array, Countable or Traversable. *