Introduce attribute #[IgnorePHPUnitWarnings]

Author: nikophil

src/Event/Emitter/DispatchingEmitter.php

@@ -10,6 +10,7 @@
 namespace PHPUnit\Event;
 
 use function assert;
+use function class_exists;
 use function memory_reset_peak_usage;
 use PHPUnit\Event\Code\ClassMethod;
 use PHPUnit\Event\Code\ComparisonFailure;
@@ -28,6 +29,8 @@
 use PHPUnit\Event\TestSuite\Started as TestSuiteStarted;
 use PHPUnit\Event\TestSuite\TestSuite;
 use PHPUnit\Framework\TestCase;
+use PHPUnit\Metadata\IgnorePHPUnitWarnings;
+use PHPUnit\Metadata\Parser\Registry;
 use PHPUnit\TextUI\Configuration\Configuration;
 use SebastianBergmann\Comparator\Comparator;
 
@@ -1008,6 +1011,17 @@ public function testTriggeredPhpunitError(Code\Test $test, string $message): voi
      */
     public function testTriggeredPhpunitWarning(Code\Test $test, string $message): void
     {
+        if (
+            $test->isTestMethod() &&
+            class_exists($test->className()) &&
+            ($metadata = Registry::parser()->forMethod($test->className(), $test->methodName())->isIgnoreWarnings())->isNotEmpty() &&
+            ($ignoreWarnings = $metadata->asArray()[0] ?? null) !== null &&
+            $ignoreWarnings instanceof IgnorePHPUnitWarnings &&
+            $ignoreWarnings->shouldIgnore($message)
+        ) {
+            return;
+        }
+
         $this->dispatcher->dispatch(
             new Test\PhpunitWarningTriggered(
                 $this->telemetryInfo(),

src/Framework/Attributes/IgnorePHPUnitWarnings.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (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\Attributes;
+
+use Attribute;
+
+/**
+ * @immutable
+ *
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ */
+#[Attribute(Attribute::TARGET_METHOD)]
+final readonly class IgnorePHPUnitWarnings
+{
+    /** @var null|non-empty-string */
+    private ?string $messagePattern;
+
+    /**
+     * @param null|non-empty-string $messagePattern
+     */
+    public function __construct(null|string $messagePattern = null)
+    {
+        $this->messagePattern = $messagePattern;
+    }
+
+    /**
+     * @return null|non-empty-string
+     */
+    public function messagePattern(): ?string
+    {
+        return $this->messagePattern;
+    }
+}

src/Metadata/IgnorePHPUnitWarnings.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (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\Metadata;
+
+use function preg_match;
+
+/**
+ * @immutable
+ *
+ * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
+ */
+final readonly class IgnorePHPUnitWarnings extends Metadata
+{
+    /** @var null|non-empty-string */
+    private ?string $messagePattern;
+
+    /**
+     * @param int<0, 1>             $level
+     * @param null|non-empty-string $messagePattern
+     */
+    protected function __construct(int $level, null|string $messagePattern)
+    {
+        parent::__construct($level);
+
+        $this->messagePattern = $messagePattern;
+    }
+
+    public function isIgnorePHPUnitWarnings(): true
+    {
+        return true;
+    }
+
+    public function shouldIgnore(string $message): bool
+    {
+        return $this->messagePattern === null ||
+            (bool) preg_match("/{$this->messagePattern}/", $message);
+    }
+}

src/Metadata/Metadata.php

@@ -534,6 +534,14 @@ public static function withoutErrorHandler(): WithoutErrorHandler
         return new WithoutErrorHandler(self::METHOD_LEVEL);
     }
 
+    /**
+     * @param null|non-empty-string $messagePattern
+     */
+    public static function ignorePHPUnitWarnings(?string $messagePattern): IgnorePHPUnitWarnings
+    {
+        return new IgnorePHPUnitWarnings(self::METHOD_LEVEL, $messagePattern);
+    }
+
     /**
      * @param int<0, 1> $level
      */
@@ -969,4 +977,12 @@ public function isWithoutErrorHandler(): bool
     {
         return false;
     }
+
+    /**
+     * @phpstan-assert-if-true IgnorePHPUnitWarnings $this
+     */
+    public function isIgnorePHPUnitWarnings(): bool
+    {
+        return false;
+    }
 }

src/Metadata/MetadataCollection.php

@@ -640,4 +640,14 @@ public function isWithoutErrorHandler(): self
             ),
         );
     }
+
+    public function isIgnoreWarnings(): self
+    {
+        return new self(
+            ...array_filter(
+                $this->metadata,
+                static fn (Metadata $metadata): bool => $metadata->isIgnorePHPUnitWarnings(),
+            ),
+        );
+    }
 }

src/Metadata/Parser/AttributeParser.php

@@ -52,6 +52,7 @@
 use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\Attributes\IgnoreDeprecations;
 use PHPUnit\Framework\Attributes\IgnorePhpunitDeprecations;
+use PHPUnit\Framework\Attributes\IgnorePHPUnitWarnings;
 use PHPUnit\Framework\Attributes\Large;
 use PHPUnit\Framework\Attributes\Medium;
 use PHPUnit\Framework\Attributes\PostCondition;
@@ -882,6 +883,13 @@ public function forMethod(string $className, string $methodName): MetadataCollec
 
                     $result[] = Metadata::withoutErrorHandler();
 
+                    break;
+
+                case IgnorePHPUnitWarnings::class:
+                    assert($attributeInstance instanceof IgnorePHPUnitWarnings);
+
+                    $result[] = Metadata::ignorePHPUnitWarnings($attributeInstance->messagePattern());
+
                     break;
             }
         }

tests/end-to-end/event/_files/PhpunitWarningIgnoredTest.php

@@ -0,0 +1,74 @@
+<?php declare(strict_types=1);
+/*
+ * This file is part of PHPUnit.
+ *
+ * (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\TestFixture\Event;
+
+use PHPUnit\Event\Facade as EventFacade;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\IgnorePHPUnitWarnings;
+use PHPUnit\Framework\TestCase;
+
+final class PhpunitWarningIgnoredTest extends TestCase
+{
+    public static function dataProvider(): iterable
+    {
+        yield [true];
+    }
+
+    #[IgnorePHPUnitWarnings]
+    public function testPhpunitWarning(): void
+    {
+        EventFacade::emitter()->testTriggeredPhpunitWarning(
+            $this->valueObjectForEvents(),
+            'warning message',
+        );
+
+        $this->assertTrue(true);
+    }
+
+    #[IgnorePHPUnitWarnings('warning message')]
+    public function testPhpunitWarningWithExactMessage(): void
+    {
+        EventFacade::emitter()->testTriggeredPhpunitWarning(
+            $this->valueObjectForEvents(),
+            'warning message',
+        );
+
+        $this->assertTrue(true);
+    }
+
+    #[IgnorePHPUnitWarnings('warn(.*)mess(.*)')]
+    public function testPhpunitWarningWithRegex(): void
+    {
+        EventFacade::emitter()->testTriggeredPhpunitWarning(
+            $this->valueObjectForEvents(),
+            'warning message',
+        );
+
+        $this->assertTrue(true);
+    }
+
+    #[IgnorePHPUnitWarnings('warn(.*)mess(.*)')]
+    public function testPhpunitWarningWithWrongPattern(): void
+    {
+        EventFacade::emitter()->testTriggeredPhpunitWarning(
+            $this->valueObjectForEvents(),
+            'another message',
+        );
+
+        $this->assertTrue(true);
+    }
+
+    #[DataProvider('dataProvider')]
+    #[IgnorePHPUnitWarnings]
+    public function testTooManyArgumentsInDataProvider(): void
+    {
+        $this->assertTrue(true);
+    }
+}

tests/end-to-end/event/phpunit-warning-ignored.phpt

@@ -0,0 +1,29 @@
+--TEST--
+The right events are emitted in the right order for a test that runs code which triggers a PHPUnit warning
+--FILE--
+<?php declare(strict_types=1);
+$_SERVER['argv'][] = '--do-not-cache-result';
+$_SERVER['argv'][] = '--no-configuration';
+$_SERVER['argv'][] = __DIR__ . '/_files/PhpunitWarningIgnoredTest.php';
+
+require __DIR__ . '/../../bootstrap.php';
+
+(new PHPUnit\TextUI\Application)->run($_SERVER['argv']);
+--EXPECTF--
+PHPUnit %s by Sebastian Bergmann and contributors.
+
+Runtime: %s
+
+...W.                                                               5 / 5 (100%)
+
+Time: %s, Memory: %s
+
+1 test triggered 1 PHPUnit warning:
+
+1) PHPUnit\TestFixture\Event\PhpunitWarningIgnoredTest::testPhpunitWarningWithWrongPattern
+another message
+
+%sPhpunitWarningIgnoredTest.php:%d
+
+OK, but there were issues!
+Tests: 5, Assertions: 5, PHPUnit Warnings: 1.