Skip to content

Commit 0d891cd

Browse files
W0rmaW0rma
committed
feat: add replacements for deprecated assertContainsOnly() and assertNotContainsOnly()
1 parent 72fc49a commit 0d891cd

File tree

2 files changed

+342
-2
lines changed

2 files changed

+342
-2
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

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

Lines changed: 315 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -99,14 +99,159 @@ 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 iterable<mixed> $haystack
136+
*/
137+
protected function assertContainsNotOnlyInt(iterable $haystack, string $message = ''): void
138+
{
139+
Assert::assertContainsNotOnlyInt($haystack, $message);
140+
}
141+
142+
/**
143+
* @param iterable<mixed> $haystack
144+
*/
145+
protected function assertContainsNotOnlyIterable(iterable $haystack, string $message = ''): void
146+
{
147+
Assert::assertContainsNotOnlyIterable($haystack, $message);
148+
}
149+
150+
/**
151+
* @param iterable<mixed> $haystack
152+
*/
153+
protected function assertContainsNotOnlyNull(iterable $haystack, string $message = ''): void
154+
{
155+
Assert::assertContainsNotOnlyNull($haystack, $message);
156+
}
157+
158+
/**
159+
* @param iterable<mixed> $haystack
160+
*/
161+
protected function assertContainsNotOnlyNumeric(iterable $haystack, string $message = ''): void
162+
{
163+
Assert::assertContainsNotOnlyNumeric($haystack, $message);
164+
}
165+
166+
/**
167+
* @param iterable<mixed> $haystack
168+
*/
169+
protected function assertContainsNotOnlyObject(iterable $haystack, string $message = ''): void
170+
{
171+
Assert::assertContainsNotOnlyObject($haystack, $message);
172+
}
173+
174+
/**
175+
* @param iterable<mixed> $haystack
176+
*/
177+
protected function assertContainsNotOnlyResource(iterable $haystack, string $message = ''): void
178+
{
179+
Assert::assertContainsNotOnlyResource($haystack, $message);
180+
}
181+
182+
/**
183+
* @param iterable<mixed> $haystack
184+
*/
185+
protected function assertContainsNotOnlyClosedResource(iterable $haystack, string $message = ''): void
186+
{
187+
Assert::assertContainsNotOnlyClosedResource($haystack, $message);
188+
}
189+
190+
/**
191+
* @param iterable<mixed> $haystack
192+
*/
193+
protected function assertContainsNotOnlyScalar(iterable $haystack, string $message = ''): void
194+
{
195+
Assert::assertContainsNotOnlyScalar($haystack, $message);
196+
}
197+
198+
/**
199+
* @param iterable<mixed> $haystack
200+
*/
201+
protected function assertContainsNotOnlyString(iterable $haystack, string $message = ''): void
202+
{
203+
Assert::assertContainsNotOnlyString($haystack, $message);
204+
}
205+
102206
/**
103207
* Asserts that a haystack contains only values of a given type.
104208
* @param 'array'|'bool'|'boolean'|'callable'|'double'|'float'|'int'|'integer'|'iterable'|'null'|'numeric'|'object'|'real'|'resource'|'resource (closed)'|'scalar'|'string' $type
105209
* @param iterable<mixed> $haystack
106210
*/
107211
protected function assertContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
108212
{
109-
Assert::assertContainsOnly($type, $haystack, $isNativeType, $message);
213+
$isNativeType ??= self::isNativeType($type);
214+
215+
if ($isNativeType) {
216+
$replacement = match ($type) {
217+
'array' => 'assertContainsOnlyArray',
218+
'bool', 'boolean' => 'assertContainsOnlyBool',
219+
'callable' => 'assertContainsOnlyCallable',
220+
'double', 'float', 'real' => 'assertContainsOnlyFloat',
221+
'int', 'integer' => 'assertContainsOnlyInt',
222+
'iterable' => 'assertContainsOnlyIterable',
223+
'null' => 'assertContainsOnlyNull',
224+
'numeric' => 'assertContainsOnlyNumeric',
225+
'object' => 'assertContainsOnlyObject',
226+
'resource' => 'assertContainsOnlyResource',
227+
'resource (closed)' => 'assertContainsOnlyClosedResource',
228+
'scalar' => 'assertContainsOnlyScalar',
229+
'string' => 'assertContainsOnlyString',
230+
};
231+
232+
trigger_error(
233+
sprintf(
234+
'%s is deprecated since PHPUnit 11.5. Please use %s($haystack) instead of assertContainsOnly(\'%s\', $haystack)',
235+
__FUNCTION__,
236+
$replacement,
237+
$type,
238+
),
239+
E_USER_DEPRECATED,
240+
);
241+
242+
$this->$replacement($haystack, $message);
243+
} else {
244+
trigger_error(
245+
sprintf(
246+
'assertContainsOnly() is deprecated since PHPUnit 11.5. Please use assertContainsOnlyInstancesOf(\'%s\', $haystack) instead of assertContainsOnly(\'%s\', $haystack).',
247+
$type,
248+
$type,
249+
),
250+
E_USER_DEPRECATED,
251+
);
252+
253+
Assert::assertContainsOnlyInstancesOf($type, $haystack, $message);
254+
}
110255
}
111256

112257
/**
@@ -119,6 +264,110 @@ protected function assertContainsOnlyInstancesOf(string $className, iterable $ha
119264
Assert::assertContainsOnlyInstancesOf($className, $haystack, $message);
120265
}
121266

267+
/**
268+
* @param iterable<mixed> $haystack
269+
*/
270+
protected function assertContainsOnlyArray(iterable $haystack, string $message = ''): void
271+
{
272+
Assert::assertContainsOnlyArray($haystack, $message);
273+
}
274+
275+
/**
276+
* @param iterable<mixed> $haystack
277+
*/
278+
protected function assertContainsOnlyBool(iterable $haystack, string $message = ''): void
279+
{
280+
Assert::assertContainsOnlyBool($haystack, $message);
281+
}
282+
283+
/**
284+
* @param iterable<mixed> $haystack
285+
*/
286+
protected function assertContainsOnlyCallable(iterable $haystack, string $message = ''): void
287+
{
288+
Assert::assertContainsOnlyCallable($haystack, $message);
289+
}
290+
291+
/**
292+
* @param iterable<mixed> $haystack
293+
*/
294+
protected function assertContainsOnlyFloat(iterable $haystack, string $message = ''): void
295+
{
296+
Assert::assertContainsOnlyFloat($haystack, $message);
297+
}
298+
299+
/**
300+
* @param iterable<mixed> $haystack
301+
*/
302+
protected function assertContainsOnlyInt(iterable $haystack, string $message = ''): void
303+
{
304+
Assert::assertContainsOnlyInt($haystack, $message);
305+
}
306+
307+
/**
308+
* @param iterable<mixed> $haystack
309+
*/
310+
protected function assertContainsOnlyIterable(iterable $haystack, string $message = ''): void
311+
{
312+
Assert::assertContainsOnlyIterable($haystack, $message);
313+
}
314+
315+
/**
316+
* @param iterable<mixed> $haystack
317+
*/
318+
protected function assertContainsOnlyNull(iterable $haystack, string $message = ''): void
319+
{
320+
Assert::assertContainsOnlyNull($haystack, $message);
321+
}
322+
323+
/**
324+
* @param iterable<mixed> $haystack
325+
*/
326+
protected function assertContainsOnlyNumeric(iterable $haystack, string $message = ''): void
327+
{
328+
Assert::assertContainsOnlyNumeric($haystack, $message);
329+
}
330+
331+
/**
332+
* @param iterable<mixed> $haystack
333+
*/
334+
protected function assertContainsOnlyObject(iterable $haystack, string $message = ''): void
335+
{
336+
Assert::assertContainsOnlyObject($haystack, $message);
337+
}
338+
339+
/**
340+
* @param iterable<mixed> $haystack
341+
*/
342+
protected function assertContainsOnlyResource(iterable $haystack, string $message = ''): void
343+
{
344+
Assert::assertContainsOnlyResource($haystack, $message);
345+
}
346+
347+
/**
348+
* @param iterable<mixed> $haystack
349+
*/
350+
protected function assertContainsOnlyClosedResource(iterable $haystack, string $message = ''): void
351+
{
352+
Assert::assertContainsOnlyClosedResource($haystack, $message);
353+
}
354+
355+
/**
356+
* @param iterable<mixed> $haystack
357+
*/
358+
protected function assertContainsOnlyScalar(iterable $haystack, string $message = ''): void
359+
{
360+
Assert::assertContainsOnlyScalar($haystack, $message);
361+
}
362+
363+
/**
364+
* @param iterable<mixed> $haystack
365+
*/
366+
protected function assertContainsOnlyString(iterable $haystack, string $message = ''): void
367+
{
368+
Assert::assertContainsOnlyString($haystack, $message);
369+
}
370+
122371
/**
123372
* Asserts the number of elements of an array, Countable or Traversable.
124373
*
@@ -838,9 +1087,73 @@ protected function assertNotContains(mixed $needle, iterable $haystack, string $
8381087
*/
8391088
protected function assertNotContainsOnly(string $type, iterable $haystack, ?bool $isNativeType = null, string $message = ''): void
8401089
{
841-
Assert::assertNotContainsOnly($type, $haystack, $isNativeType, $message);
1090+
$isNativeType ??= self::isNativeType($type);
1091+
1092+
if ($isNativeType) {
1093+
$replacement = match ($type) {
1094+
'array' => 'assertContainsNotOnlyArray',
1095+
'bool', 'boolean' => 'assertContainsNotOnlyBool',
1096+
'callable' => 'assertContainsNotOnlyCallable',
1097+
'double', 'float', 'real' => 'assertContainsNotOnlyFloat',
1098+
'int', 'integer' => 'assertContainsNotOnlyInt',
1099+
'iterable' => 'assertContainsNotOnlyIterable',
1100+
'null' => 'assertContainsNotOnlyNull',
1101+
'numeric' => 'assertContainsNotOnlyNumeric',
1102+
'object' => 'assertContainsNotOnlyObject',
1103+
'resource' => 'assertContainsNotOnlyResource',
1104+
'resource (closed)' => 'assertContainsNotOnlyClosedResource',
1105+
'scalar' => 'assertContainsNotOnlyScalar',
1106+
'string' => 'assertContainsNotOnlyString',
1107+
};
1108+
1109+
trigger_error(
1110+
sprintf(
1111+
'%s is deprecated since PHPUnit 11.5. Please use %s($haystack) instead of assertContainsNotOnly(\'%s\', $haystack)',
1112+
__FUNCTION__,
1113+
$replacement,
1114+
$type,
1115+
),
1116+
E_USER_DEPRECATED,
1117+
);
1118+
1119+
$this->$replacement($haystack, $message);
1120+
} else {
1121+
trigger_error(
1122+
sprintf(
1123+
'assertNotContainsOnly() is deprecated since PHPUnit 11.5. Please use assertContainsNotOnlyInstancesOf(\'%s\', $haystack) instead of assertNotContainsOnly(\'%s\', $haystack).',
1124+
$type,
1125+
$type,
1126+
),
1127+
E_USER_DEPRECATED,
1128+
);
1129+
1130+
Assert::assertContainsNotOnlyInstancesOf($type, $haystack, $message);
1131+
}
8421132
}
8431133

1134+
private static function isNativeType(string $type): bool
1135+
{
1136+
return in_array($type, [
1137+
'array',
1138+
'bool',
1139+
'boolean',
1140+
'callable',
1141+
'double',
1142+
'float',
1143+
'int',
1144+
'integer',
1145+
'iterable',
1146+
'null',
1147+
'numeric',
1148+
'object',
1149+
'real',
1150+
'resource',
1151+
'resource (closed)',
1152+
'scalar',
1153+
'string',
1154+
]);
1155+
}
1156+
8441157
/**
8451158
* Asserts the number of elements of an array, Countable or Traversable.
8461159
*

0 commit comments

Comments
 (0)