Skip to content

Commit 1caa11f

Browse files
W0rmaW0rma
committed
feat: add replacements for deprecated assertContainsOnly() and assertNotContainsOnly()
1 parent dec0f6e commit 1caa11f

File tree

3 files changed

+337
-6
lines changed

3 files changed

+337
-6
lines changed

‎docs/supported_asserts.md‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,8 +20,35 @@ assertClassNotHasAttribute
2020
assertClassNotHasStaticAttribute
2121
assertContains
2222
assertContainsEquals
23+
assertContainsNotOnlyArray
24+
assertContainsNotOnlyBool
25+
assertContainsNotOnlyCallable
26+
assertContainsNotOnlyClosedResource
27+
assertContainsNotOnlyFloat
28+
assertContainsNotOnlyInstancesOf
29+
assertContainsNotOnlyInt
30+
assertContainsNotOnlyIterable
31+
assertContainsNotOnlyNull
32+
assertContainsNotOnlyNumeric
33+
assertContainsNotOnlyObject
34+
assertContainsNotOnlyResource
35+
assertContainsNotOnlyScalar
36+
assertContainsNotOnlyString
2337
assertContainsOnly
38+
assertContainsOnlyArray
39+
assertContainsOnlyBool
40+
assertContainsOnlyCallable
41+
assertContainsOnlyClosedResource
42+
assertContainsOnlyFloat
2443
assertContainsOnlyInstancesOf
44+
assertContainsOnlyInt
45+
assertContainsOnlyIterable
46+
assertContainsOnlyNull
47+
assertContainsOnlyNumeric
48+
assertContainsOnlyObject
49+
assertContainsOnlyResource
50+
assertContainsOnlyScalar
51+
assertContainsOnlyString
2552
assertCount
2653
assertDirectoryDoesNotExist
2754
assertDirectoryExists

‎phpstan.neon‎

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,4 +2,11 @@ parameters:
22
level: 9
33
paths:
44
- tests/
5-
- src/
5+
- src/
6+
ignoreErrors:
7+
-
8+
message: '#Parameter \#1 \$className of static method PHPUnit\\Framework\\Assert::assertContainsOnlyInstancesOf\(\) expects class-string<object>, string given\.#'
9+
path: src/Codeception/Util/Shared/InheritedAsserts.php
10+
-
11+
message: '#Parameter \#1 \$className of static method PHPUnit\\Framework\\Assert::assertContainsNotOnlyInstancesOf\(\) expects class-string, string given\.#'
12+
path: src/Codeception/Util/Shared/InheritedAsserts.php

‎src/Codeception/Util/Shared/InheritedAsserts.php‎

Lines changed: 302 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -99,14 +99,167 @@ protected function assertNotContainsEquals(mixed $needle, iterable $haystack, st
9999
Assert::assertNotContainsEquals($needle, $haystack, $message);
100100
}
101101

102+
/**
103+
* @param iterable<mixed> $haystack
104+
*/
105+
protected function assertContainsNotOnlyArray(iterable $haystack, string $message = ''): void
106+
{
107+
Assert::assertContainsNotOnlyArray($haystack, $message);
108+
}
109+
110+
/**
111+
* @param iterable<mixed> $haystack
112+
*/
113+
protected function assertContainsNotOnlyBool(iterable $haystack, string $message = ''): void
114+
{
115+
Assert::assertContainsNotOnlyBool($haystack, $message);
116+
}
117+
118+
/**
119+
* @param iterable<mixed> $haystack
120+
*/
121+
protected function assertContainsNotOnlyCallable(iterable $haystack, string $message = ''): void
122+
{
123+
Assert::assertContainsNotOnlyCallable($haystack, $message);
124+
}
125+
126+
/**
127+
* @param iterable<mixed> $haystack
128+
*/
129+
protected function assertContainsNotOnlyFloat(iterable $haystack, string $message = ''): void
130+
{
131+
Assert::assertContainsNotOnlyFloat($haystack, $message);
132+
}
133+
134+
/**
135+
* @param class-string $className
136+
* @param iterable<mixed> $haystack
137+
*/
138+
protected function assertContainsNotOnlyInstancesOf(string $className, iterable $haystack, string $message = ''): void
139+
{
140+
Assert::assertContainsNotOnlyInstancesOf($className, $haystack, $message);
141+
}
142+
143+
/**
144+
* @param iterable<mixed> $haystack
145+
*/
146+
protected function assertContainsNotOnlyInt(iterable $haystack, string $message = ''): void
147+
{
148+
Assert::assertContainsNotOnlyInt($haystack, $message);
149+
}
150+
151+
/**
152+
* @param iterable<mixed> $haystack
153+
*/
154+
protected function assertContainsNotOnlyIterable(iterable $haystack, string $message = ''): void
155+
{
156+
Assert::assertContainsNotOnlyIterable($haystack, $message);
157+
}
158+
159+
/**
160+
* @param iterable<mixed> $haystack
161+
*/
162+
protected function assertContainsNotOnlyNull(iterable $haystack, string $message = ''): void
163+
{
164+
Assert::assertContainsNotOnlyNull($haystack, $message);
165+
}
166+
167+
/**
168+
* @param iterable<mixed> $haystack
169+
*/
170+
protected function assertContainsNotOnlyNumeric(iterable $haystack, string $message = ''): void
171+
{
172+
Assert::assertContainsNotOnlyNumeric($haystack, $message);
173+
}
174+
175+
/**
176+
* @param iterable<mixed> $haystack
177+
*/
178+
protected function assertContainsNotOnlyObject(iterable $haystack, string $message = ''): void
179+
{
180+
Assert::assertContainsNotOnlyObject($haystack, $message);
181+
}
182+
183+
/**
184+
* @param iterable<mixed> $haystack
185+
*/
186+
protected function assertContainsNotOnlyResource(iterable $haystack, string $message = ''): void
187+
{
188+
Assert::assertContainsNotOnlyResource($haystack, $message);
189+
}
190+
191+
/**
192+
* @param iterable<mixed> $haystack
193+
*/
194+
protected function assertContainsNotOnlyClosedResource(iterable $haystack, string $message = ''): void
195+
{
196+
Assert::assertContainsNotOnlyClosedResource($haystack, $message);
197+
}
198+
199+
/**
200+
* @param iterable<mixed> $haystack
201+
*/
202+
protected function assertContainsNotOnlyScalar(iterable $haystack, string $message = ''): void
203+
{
204+
Assert::assertContainsNotOnlyScalar($haystack, $message);
205+
}
206+
207+
/**
208+
* @param iterable<mixed> $haystack
209+
*/
210+
protected function assertContainsNotOnlyString(iterable $haystack, string $message = ''): void
211+
{
212+
Assert::assertContainsNotOnlyString($haystack, $message);
213+
}
214+
102215
/**
103216
* Asserts that a haystack contains only values of a given type.
104-
* @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string' $type
217+
* @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string'|class-string $type
105218
* @param iterable<mixed> $haystack
106219
*/
107220
protected function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
108221
{
109-
Assert::assertContainsOnly($type, $haystack, $isNativeType, $message);
222+
$replacement = match ($type) {
223+
'array' => 'assertContainsOnlyArray',
224+
'bool', 'boolean' => 'assertContainsOnlyBool',
225+
'callable' => 'assertContainsOnlyCallable',
226+
'double', 'float', 'real' => 'assertContainsOnlyFloat',
227+
'int', 'integer' => 'assertContainsOnlyInt',
228+
'iterable' => 'assertContainsOnlyIterable',
229+
'null' => 'assertContainsOnlyNull',
230+
'numeric' => 'assertContainsOnlyNumeric',
231+
'object' => 'assertContainsOnlyObject',
232+
'resource' => 'assertContainsOnlyResource',
233+
'resource (closed)' => 'assertContainsOnlyClosedResource',
234+
'scalar' => 'assertContainsOnlyScalar',
235+
'string' => 'assertContainsOnlyString',
236+
default => null,
237+
};
238+
239+
if (is_string($replacement)) {
240+
trigger_error(
241+
sprintf(
242+
'%s is deprecated since PHPUnit 11.5. Please use %s($haystack) instead of assertContainsOnly(\'%s\', $haystack)',
243+
__FUNCTION__,
244+
$replacement,
245+
$type,
246+
),
247+
E_USER_DEPRECATED,
248+
);
249+
250+
$this->$replacement($haystack, $message);
251+
} else {
252+
trigger_error(
253+
sprintf(
254+
'assertContainsOnly() is deprecated since PHPUnit 11.5. Please use assertContainsOnlyInstancesOf(\'%s\', $haystack) instead of assertContainsOnly(\'%s\', $haystack).',
255+
$type,
256+
$type,
257+
),
258+
E_USER_DEPRECATED,
259+
);
260+
261+
Assert::assertContainsOnlyInstancesOf($type, $haystack, $message);
262+
}
110263
}
111264

112265
/**
@@ -119,6 +272,110 @@ protected function assertContainsOnlyInstancesOf(string $className, iterable $ha
119272
Assert::assertContainsOnlyInstancesOf($className, $haystack, $message);
120273
}
121274

275+
/**
276+
* @param iterable<mixed> $haystack
277+
*/
278+
protected function assertContainsOnlyArray(iterable $haystack, string $message = ''): void
279+
{
280+
Assert::assertContainsOnlyArray($haystack, $message);
281+
}
282+
283+
/**
284+
* @param iterable<mixed> $haystack
285+
*/
286+
protected function assertContainsOnlyBool(iterable $haystack, string $message = ''): void
287+
{
288+
Assert::assertContainsOnlyBool($haystack, $message);
289+
}
290+
291+
/**
292+
* @param iterable<mixed> $haystack
293+
*/
294+
protected function assertContainsOnlyCallable(iterable $haystack, string $message = ''): void
295+
{
296+
Assert::assertContainsOnlyCallable($haystack, $message);
297+
}
298+
299+
/**
300+
* @param iterable<mixed> $haystack
301+
*/
302+
protected function assertContainsOnlyFloat(iterable $haystack, string $message = ''): void
303+
{
304+
Assert::assertContainsOnlyFloat($haystack, $message);
305+
}
306+
307+
/**
308+
* @param iterable<mixed> $haystack
309+
*/
310+
protected function assertContainsOnlyInt(iterable $haystack, string $message = ''): void
311+
{
312+
Assert::assertContainsOnlyInt($haystack, $message);
313+
}
314+
315+
/**
316+
* @param iterable<mixed> $haystack
317+
*/
318+
protected function assertContainsOnlyIterable(iterable $haystack, string $message = ''): void
319+
{
320+
Assert::assertContainsOnlyIterable($haystack, $message);
321+
}
322+
323+
/**
324+
* @param iterable<mixed> $haystack
325+
*/
326+
protected function assertContainsOnlyNull(iterable $haystack, string $message = ''): void
327+
{
328+
Assert::assertContainsOnlyNull($haystack, $message);
329+
}
330+
331+
/**
332+
* @param iterable<mixed> $haystack
333+
*/
334+
protected function assertContainsOnlyNumeric(iterable $haystack, string $message = ''): void
335+
{
336+
Assert::assertContainsOnlyNumeric($haystack, $message);
337+
}
338+
339+
/**
340+
* @param iterable<mixed> $haystack
341+
*/
342+
protected function assertContainsOnlyObject(iterable $haystack, string $message = ''): void
343+
{
344+
Assert::assertContainsOnlyObject($haystack, $message);
345+
}
346+
347+
/**
348+
* @param iterable<mixed> $haystack
349+
*/
350+
protected function assertContainsOnlyResource(iterable $haystack, string $message = ''): void
351+
{
352+
Assert::assertContainsOnlyResource($haystack, $message);
353+
}
354+
355+
/**
356+
* @param iterable<mixed> $haystack
357+
*/
358+
protected function assertContainsOnlyClosedResource(iterable $haystack, string $message = ''): void
359+
{
360+
Assert::assertContainsOnlyClosedResource($haystack, $message);
361+
}
362+
363+
/**
364+
* @param iterable<mixed> $haystack
365+
*/
366+
protected function assertContainsOnlyScalar(iterable $haystack, string $message = ''): void
367+
{
368+
Assert::assertContainsOnlyScalar($haystack, $message);
369+
}
370+
371+
/**
372+
* @param iterable<mixed> $haystack
373+
*/
374+
protected function assertContainsOnlyString(iterable $haystack, string $message = ''): void
375+
{
376+
Assert::assertContainsOnlyString($haystack, $message);
377+
}
378+
122379
/**
123380
* Asserts the number of elements of an array, Countable or Traversable.
124381
*
@@ -833,14 +1090,54 @@ protected function assertNotContains(mixed $needle, iterable $haystack, string $
8331090

8341091
/**
8351092
* Asserts that a haystack does not contain only values of a given type.
836-
* @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string' $type
1093+
* @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string'|class-string $type
8371094
* @param iterable<mixed> $haystack
8381095
*/
8391096
protected function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
8401097
{
841-
Assert::assertNotContainsOnly($type, $haystack, $isNativeType, $message);
1098+
$replacement = match ($type) {
1099+
'array' => 'assertContainsNotOnlyArray',
1100+
'bool', 'boolean' => 'assertContainsNotOnlyBool',
1101+
'callable' => 'assertContainsNotOnlyCallable',
1102+
'double', 'float', 'real' => 'assertContainsNotOnlyFloat',
1103+
'int', 'integer' => 'assertContainsNotOnlyInt',
1104+
'iterable' => 'assertContainsNotOnlyIterable',
1105+
'null' => 'assertContainsNotOnlyNull',
1106+
'numeric' => 'assertContainsNotOnlyNumeric',
1107+
'object' => 'assertContainsNotOnlyObject',
1108+
'resource' => 'assertContainsNotOnlyResource',
1109+
'resource (closed)' => 'assertContainsNotOnlyClosedResource',
1110+
'scalar' => 'assertContainsNotOnlyScalar',
1111+
'string' => 'assertContainsNotOnlyString',
1112+
default => null,
1113+
};
1114+
1115+
if (is_string($replacement)) {
1116+
trigger_error(
1117+
sprintf(
1118+
'%s is deprecated since PHPUnit 11.5. Please use %s($haystack) instead of assertContainsNotOnly(\'%s\', $haystack)',
1119+
__FUNCTION__,
1120+
$replacement,
1121+
$type,
1122+
),
1123+
E_USER_DEPRECATED,
1124+
);
1125+
1126+
$this->$replacement($haystack, $message);
1127+
} else {
1128+
trigger_error(
1129+
sprintf(
1130+
'assertNotContainsOnly() is deprecated since PHPUnit 11.5. Please use assertContainsNotOnlyInstancesOf(\'%s\', $haystack) instead of assertNotContainsOnly(\'%s\', $haystack).',
1131+
$type,
1132+
$type,
1133+
),
1134+
E_USER_DEPRECATED,
1135+
);
1136+
1137+
Assert::assertContainsNotOnlyInstancesOf($type, $haystack, $message);
1138+
}
8421139
}
843-
1140+
8441141
/**
8451142
* Asserts the number of elements of an array, Countable or Traversable.
8461143
*

0 commit comments

Comments
 (0)