From a246003ef814cb76a631a5e73a14c11802c14479 Mon Sep 17 00:00:00 2001
From: cs <cs@amedick-sommer.de>
Date: Tue, 31 Mar 2026 19:16:18 +0200
Subject: [PATCH 1/2] [TASK] Add ProcessorSkipperTest for processor skipping
 functionality
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 🧪 Implement tests to verify processors not in skip list are not skipped
- ✅ Add tests for single processor in skip list being skipped
- 🔄 Ensure other processors are unaffected when one is skipped
- 🚀 Test multiple processors can be skipped simultaneously
- ✔️ Validate all processors can be skipped when configured
---
 .../ProcessorSkipper/ProcessorSkipperTest.php | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php

diff --git a/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php b/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php
new file mode 100644
index 00000000..2906bf79
--- /dev/null
+++ b/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php
@@ -0,0 +1,114 @@
+<?php
+
+declare(strict_types=1);
+
+namespace a9f\Fractor\Tests\Application\ProcessorSkipper;
+
+use a9f\Fractor\Application\ProcessorSkipper;
+use a9f\Fractor\Configuration\ValueObject\SkipConfiguration;
+use a9f\FractorFluid\FluidFileProcessor;
+use a9f\FractorHtaccess\HtaccessFileProcessor;
+use a9f\FractorTypoScript\TypoScriptFileProcessor;
+use a9f\FractorXml\XmlFileProcessor;
+use a9f\FractorYaml\YamlFileProcessor;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+final class ProcessorSkipperTest extends TestCase
+{
+    #[Test]
+    public function processorNotInSkipListIsNotSkipped(): void
+    {
+        $configuration = new SkipConfiguration([]);
+        $subject = new ProcessorSkipper($configuration);
+
+        self::assertFalse($subject->shouldSkip(FluidFileProcessor::class));
+        self::assertFalse($subject->shouldSkip(HtaccessFileProcessor::class));
+        self::assertFalse($subject->shouldSkip(TypoScriptFileProcessor::class));
+        self::assertFalse($subject->shouldSkip(XmlFileProcessor::class));
+        self::assertFalse($subject->shouldSkip(YamlFileProcessor::class));
+    }
+
+    /**
+     * @return \Generator<string, array{class-string}>
+     */
+    public static function skippableProcessorProvider(): \Generator
+    {
+        yield 'FluidFileProcessor' => [FluidFileProcessor::class];
+        yield 'HtaccessFileProcessor' => [HtaccessFileProcessor::class];
+        yield 'TypoScriptFileProcessor' => [TypoScriptFileProcessor::class];
+        yield 'XmlFileProcessor' => [XmlFileProcessor::class];
+        yield 'YamlFileProcessor' => [YamlFileProcessor::class];
+    }
+
+    #[Test]
+    #[DataProvider('skippableProcessorProvider')]
+    public function singleProcessorInSkipListIsSkipped(string $processorClass): void
+    {
+        $configuration = new SkipConfiguration([$processorClass]);
+        $subject = new ProcessorSkipper($configuration);
+
+        self::assertTrue($subject->shouldSkip($processorClass));
+    }
+
+    #[Test]
+    #[DataProvider('skippableProcessorProvider')]
+    public function otherProcessorsAreNotAffectedWhenOneIsSkipped(string $skippedProcessor): void
+    {
+        $allProcessors = [
+            FluidFileProcessor::class,
+            HtaccessFileProcessor::class,
+            TypoScriptFileProcessor::class,
+            XmlFileProcessor::class,
+            YamlFileProcessor::class,
+        ];
+
+        $configuration = new SkipConfiguration([$skippedProcessor]);
+        $subject = new ProcessorSkipper($configuration);
+
+        foreach ($allProcessors as $processor) {
+            if ($processor === $skippedProcessor) {
+                self::assertTrue($subject->shouldSkip($processor), $processor . ' should be skipped');
+            } else {
+                self::assertFalse($subject->shouldSkip($processor), $processor . ' should not be skipped');
+            }
+        }
+    }
+
+    #[Test]
+    public function multipleProcessorsCanBeSkippedSimultaneously(): void
+    {
+        $configuration = new SkipConfiguration([
+            FluidFileProcessor::class,
+            XmlFileProcessor::class,
+            YamlFileProcessor::class,
+        ]);
+        $subject = new ProcessorSkipper($configuration);
+
+        self::assertTrue($subject->shouldSkip(FluidFileProcessor::class));
+        self::assertFalse($subject->shouldSkip(HtaccessFileProcessor::class));
+        self::assertFalse($subject->shouldSkip(TypoScriptFileProcessor::class));
+        self::assertTrue($subject->shouldSkip(XmlFileProcessor::class));
+        self::assertTrue($subject->shouldSkip(YamlFileProcessor::class));
+    }
+
+    #[Test]
+    public function allProcessorsCanBeSkipped(): void
+    {
+        $configuration = new SkipConfiguration([
+            FluidFileProcessor::class,
+            HtaccessFileProcessor::class,
+            TypoScriptFileProcessor::class,
+            XmlFileProcessor::class,
+            YamlFileProcessor::class,
+        ]);
+        $subject = new ProcessorSkipper($configuration);
+
+        self::assertTrue($subject->shouldSkip(FluidFileProcessor::class));
+        self::assertTrue($subject->shouldSkip(HtaccessFileProcessor::class));
+        self::assertTrue($subject->shouldSkip(TypoScriptFileProcessor::class));
+        self::assertTrue($subject->shouldSkip(XmlFileProcessor::class));
+        self::assertTrue($subject->shouldSkip(YamlFileProcessor::class));
+    }
+}

From 5193ae80047b1c4267579ac06f0cfe41dad63978 Mon Sep 17 00:00:00 2001
From: cs <cs@amedick-sommer.de>
Date: Tue, 31 Mar 2026 19:35:37 +0200
Subject: [PATCH 2/2] [TASK] Fix PHPStan errors in ProcessorSkipperTest

Remove unnecessary generic type annotation from ProcessorSkipper::shouldSkip() since the method only performs a string comparison via in_array().
This resolves PHPStan covariance errors when passing concrete FileProcessor class-strings in tests.
---
 .../src/Application/ProcessorSkipper.php      |  5 --
 .../ProcessorSkipper/ProcessorSkipperTest.php | 53 +++++++++----------
 2 files changed, 24 insertions(+), 34 deletions(-)

diff --git a/packages/fractor/src/Application/ProcessorSkipper.php b/packages/fractor/src/Application/ProcessorSkipper.php
index 551364d5..fe4ced26 100644
--- a/packages/fractor/src/Application/ProcessorSkipper.php
+++ b/packages/fractor/src/Application/ProcessorSkipper.php
@@ -4,8 +4,6 @@
 
 namespace a9f\Fractor\Application;
 
-use a9f\Fractor\Application\Contract\FileProcessor;
-use a9f\Fractor\Application\Contract\FractorRule;
 use a9f\Fractor\Configuration\ValueObject\SkipConfiguration;
 
 final readonly class ProcessorSkipper
@@ -15,9 +13,6 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @param class-string<FileProcessor<FractorRule>> $processor
-     */
     public function shouldSkip(string $processor): bool
     {
         $configuredSkip = $this->configuration->getSkip();
diff --git a/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php b/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php
index 2906bf79..643680ee 100644
--- a/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php
+++ b/packages/fractor/tests/Application/ProcessorSkipper/ProcessorSkipperTest.php
@@ -23,23 +23,20 @@ public function processorNotInSkipListIsNotSkipped(): void
         $configuration = new SkipConfiguration([]);
         $subject = new ProcessorSkipper($configuration);
 
-        self::assertFalse($subject->shouldSkip(FluidFileProcessor::class));
-        self::assertFalse($subject->shouldSkip(HtaccessFileProcessor::class));
-        self::assertFalse($subject->shouldSkip(TypoScriptFileProcessor::class));
-        self::assertFalse($subject->shouldSkip(XmlFileProcessor::class));
-        self::assertFalse($subject->shouldSkip(YamlFileProcessor::class));
+        foreach (self::allProcessorClasses() as $processorClass) {
+            self::assertFalse($subject->shouldSkip($processorClass));
+        }
     }
 
     /**
-     * @return \Generator<string, array{class-string}>
+     * @return \Generator<string, array{string}>
      */
     public static function skippableProcessorProvider(): \Generator
     {
-        yield 'FluidFileProcessor' => [FluidFileProcessor::class];
-        yield 'HtaccessFileProcessor' => [HtaccessFileProcessor::class];
-        yield 'TypoScriptFileProcessor' => [TypoScriptFileProcessor::class];
-        yield 'XmlFileProcessor' => [XmlFileProcessor::class];
-        yield 'YamlFileProcessor' => [YamlFileProcessor::class];
+        foreach (self::allProcessorClasses() as $processorClass) {
+            $shortName = (new \ReflectionClass($processorClass))->getShortName();
+            yield $shortName => [$processorClass];
+        }
     }
 
     #[Test]
@@ -56,18 +53,10 @@ public function singleProcessorInSkipListIsSkipped(string $processorClass): void
     #[DataProvider('skippableProcessorProvider')]
     public function otherProcessorsAreNotAffectedWhenOneIsSkipped(string $skippedProcessor): void
     {
-        $allProcessors = [
-            FluidFileProcessor::class,
-            HtaccessFileProcessor::class,
-            TypoScriptFileProcessor::class,
-            XmlFileProcessor::class,
-            YamlFileProcessor::class,
-        ];
-
         $configuration = new SkipConfiguration([$skippedProcessor]);
         $subject = new ProcessorSkipper($configuration);
 
-        foreach ($allProcessors as $processor) {
+        foreach (self::allProcessorClasses() as $processor) {
             if ($processor === $skippedProcessor) {
                 self::assertTrue($subject->shouldSkip($processor), $processor . ' should be skipped');
             } else {
@@ -96,19 +85,25 @@ public function multipleProcessorsCanBeSkippedSimultaneously(): void
     #[Test]
     public function allProcessorsCanBeSkipped(): void
     {
-        $configuration = new SkipConfiguration([
+        $configuration = new SkipConfiguration(self::allProcessorClasses());
+        $subject = new ProcessorSkipper($configuration);
+
+        foreach (self::allProcessorClasses() as $processorClass) {
+            self::assertTrue($subject->shouldSkip($processorClass));
+        }
+    }
+
+    /**
+     * @return list<class-string>
+     */
+    private static function allProcessorClasses(): array
+    {
+        return [
             FluidFileProcessor::class,
             HtaccessFileProcessor::class,
             TypoScriptFileProcessor::class,
             XmlFileProcessor::class,
             YamlFileProcessor::class,
-        ]);
-        $subject = new ProcessorSkipper($configuration);
-
-        self::assertTrue($subject->shouldSkip(FluidFileProcessor::class));
-        self::assertTrue($subject->shouldSkip(HtaccessFileProcessor::class));
-        self::assertTrue($subject->shouldSkip(TypoScriptFileProcessor::class));
-        self::assertTrue($subject->shouldSkip(XmlFileProcessor::class));
-        self::assertTrue($subject->shouldSkip(YamlFileProcessor::class));
+        ];
     }
 }