feat: add tests for introspection processor behavior

- Added test for processing of non-trackable log levels, ensuring no modification of the log record.
- Added test for processing of trackable log levels, verifying introspection data is added to the context.
- Added test to validate respect for custom stack depth in introspection.
- Added test to ensure original context is preserved when introspection is applied.
- Added test for handling invalid trace depth in introspection with reflection.

Author: walmir-silva

tests/Processor/IntrospectionProcessorTest.php

@@ -2,30 +2,111 @@
 
 declare(strict_types=1);
 
-namespace KaririCode\Logging\Tests\Processor;
+namespace Tests\KaririCode\Logging\Processor;
 
+use KaririCode\Contract\ImmutableValue;
 use KaririCode\Logging\LogLevel;
 use KaririCode\Logging\LogRecord;
 use KaririCode\Logging\Processor\IntrospectionProcessor;
 use PHPUnit\Framework\TestCase;
 
-class IntrospectionProcessorTest extends TestCase
+final class IntrospectionProcessorTest extends TestCase
 {
-    private IntrospectionProcessor $introspectionProcessor;
+    private IntrospectionProcessor $processor;
 
     protected function setUp(): void
     {
-        $this->introspectionProcessor = new IntrospectionProcessor();
+        $this->processor = new IntrospectionProcessor();
     }
 
-    public function testProcessHappyPath(): void
+    /**
+     * @dataProvider provideNonTrackableLevels
+     */
+    public function testProcessDoesNotModifyRecordForNonTrackableLevels(LogLevel $level): void
     {
-        $record = new LogRecord(LogLevel::INFO, 'Test message');
-        $processedRecord = $this->introspectionProcessor->process($record);
+        $record = $this->createMockRecord($level);
+        $processedRecord = $this->processor->process($record);
+        $this->assertSame($record, $processedRecord);
+    }
 
+    /**
+     * @dataProvider provideTrackableLevels
+     */
+    public function testProcessAddsIntrospectionDataForTrackableLevels(LogLevel $level): void
+    {
+        $record = $this->createMockRecord($level);
+        $processedRecord = $this->processor->process($record);
+        $this->assertInstanceOf(LogRecord::class, $processedRecord);
         $this->assertArrayHasKey('file', $processedRecord->context);
         $this->assertArrayHasKey('line', $processedRecord->context);
         $this->assertArrayHasKey('class', $processedRecord->context);
         $this->assertArrayHasKey('function', $processedRecord->context);
     }
+
+    public function testProcessRespectsStackDepth(): void
+    {
+        $customDepthProcessor = new IntrospectionProcessor(2);
+        $record = $this->createMockRecord(LogLevel::ERROR);
+        $processedRecord = $customDepthProcessor->process($record);
+        $this->assertInstanceOf(LogRecord::class, $processedRecord);
+        $this->assertArrayHasKey('file', $processedRecord->context);
+    }
+
+    public function testProcessPreservesOriginalContext(): void
+    {
+        $originalContext = ['key' => 'value'];
+        $record = $this->createMockRecord(LogLevel::ERROR, $originalContext);
+        $processedRecord = $this->processor->process($record);
+        $this->assertInstanceOf(LogRecord::class, $processedRecord);
+        $this->assertArrayHasKey('key', $processedRecord->context);
+        $this->assertEquals('value', $processedRecord->context['key']);
+    }
+
+    public function testGetMaxDepthHandlesInvalidTraceDepth(): void
+    {
+        $reflection = new \ReflectionClass(IntrospectionProcessor::class);
+        $getMaxDepthMethod = $reflection->getMethod('getMaxDepth');
+        $getMaxDepthMethod->setAccessible(true);
+        $deepProcessor = new IntrospectionProcessor(1000);
+        $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
+        $maxDepth = $getMaxDepthMethod->invoke($deepProcessor, $trace);
+        $this->assertLessThanOrEqual(count($trace) - 1, $maxDepth);
+        $this->assertGreaterThan(0, $maxDepth);
+    }
+
+    /**
+     * @return array<array{0: LogLevel}>
+     */
+    public static function provideNonTrackableLevels(): array
+    {
+        return [
+            [LogLevel::DEBUG],
+            [LogLevel::INFO],
+            [LogLevel::NOTICE],
+            [LogLevel::WARNING],
+        ];
+    }
+
+    /**
+     * @return array<array{0: LogLevel}>
+     */
+    public static function provideTrackableLevels(): array
+    {
+        return [
+            [LogLevel::ERROR],
+            [LogLevel::CRITICAL],
+            [LogLevel::ALERT],
+            [LogLevel::EMERGENCY],
+        ];
+    }
+
+    private function createMockRecord(LogLevel $level, array $context = []): ImmutableValue
+    {
+        return new LogRecord(
+            $level,
+            'Test message',
+            $context,
+            new \DateTimeImmutable()
+        );
+    }
 }