test: increase unit test coverage to 84%

tests/Unit/API/Baggage/BaggageBuilderTest.php

@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Unit\API\Baggage;
+
+use OpenTelemetry\API\Baggage\BaggageBuilder;
+use OpenTelemetry\API\Baggage\BaggageInterface;
+use OpenTelemetry\API\Baggage\Metadata;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(BaggageBuilder::class)]
+class BaggageBuilderTest extends TestCase
+{
+    public function test_build_returns_baggage(): void
+    {
+        $builder = new BaggageBuilder();
+        $this->assertInstanceOf(BaggageInterface::class, $builder->build());
+    }
+
+    public function test_set_adds_entry(): void
+    {
+        $builder = new BaggageBuilder();
+        $result = $builder->set('key', 'value');
+        $this->assertSame($builder, $result);
+        $baggage = $builder->build();
+        $entry = $baggage->getEntry('key');
+        $this->assertNotNull($entry);
+        $this->assertSame('value', $entry->getValue());
+    }
+
+    public function test_set_with_metadata(): void
+    {
+        $metadata = new Metadata('meta');
+        $builder = new BaggageBuilder();
+        $builder->set('key', 'value', $metadata);
+        $baggage = $builder->build();
+        $entry = $baggage->getEntry('key');
+        $this->assertNotNull($entry);
+        $this->assertSame('meta', $entry->getMetadata()->getValue());
+    }
+
+    public function test_set_empty_key_is_ignored(): void
+    {
+        $builder = new BaggageBuilder();
+        $result = $builder->set('', 'value');
+        $this->assertSame($builder, $result);
+        $baggage = $builder->build();
+        $this->assertNull($baggage->getEntry(''));
+    }
+
+    public function test_remove_removes_entry(): void
+    {
+        $builder = new BaggageBuilder();
+        $builder->set('key', 'value');
+        $result = $builder->remove('key');
+        $this->assertSame($builder, $result);
+        $baggage = $builder->build();
+        $this->assertNull($baggage->getEntry('key'));
+    }
+
+    public function test_set_overwrites_existing(): void
+    {
+        $builder = new BaggageBuilder();
+        $builder->set('key', 'first');
+        $builder->set('key', 'second');
+        $baggage = $builder->build();
+        $this->assertSame('second', $baggage->getEntry('key')->getValue());
+    }
+}

tests/Unit/API/Baggage/MetadataTest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Unit\API\Baggage;
+
+use OpenTelemetry\API\Baggage\Metadata;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(Metadata::class)]
+class MetadataTest extends TestCase
+{
+    public function test_get_value(): void
+    {
+        $metadata = new Metadata('some-metadata');
+
+        $this->assertSame('some-metadata', $metadata->getValue());
+    }
+
+    public function test_get_empty_returns_metadata_with_empty_value(): void
+    {
+        $metadata = Metadata::getEmpty();
+
+        $this->assertSame('', $metadata->getValue());
+    }
+
+    public function test_get_empty_returns_same_instance(): void
+    {
+        $this->assertSame(Metadata::getEmpty(), Metadata::getEmpty());
+    }
+
+    public function test_constructor_with_empty_string(): void
+    {
+        $metadata = new Metadata('');
+
+        $this->assertSame('', $metadata->getValue());
+    }
+
+    public function test_constructor_with_complex_value(): void
+    {
+        $value = 'key1=value1;key2=value2';
+        $metadata = new Metadata($value);
+
+        $this->assertSame($value, $metadata->getValue());
+    }
+}

tests/Unit/API/Behavior/Internal/LogWriter/ErrorLogWriterTest.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Unit\API\Behavior\Internal\LogWriter;
+
+use OpenTelemetry\API\Behavior\Internal\LogWriter\ErrorLogWriter;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(ErrorLogWriter::class)]
+final class ErrorLogWriterTest extends TestCase
+{
+    public function test_write_calls_error_log(): void
+    {
+        $writer = new ErrorLogWriter();
+
+        // Capture error_log output by redirecting to a temp file
+        $file = tempnam(sys_get_temp_dir(), 'otel_errorlog_');
+        $this->assertNotFalse($file);
+
+        try {
+            ini_set('error_log', $file);
+            $writer->write('warning', 'test error log message', []);
+
+            $contents = file_get_contents($file);
+            $this->assertStringContainsString('test error log message', $contents);
+        } finally {
+            ini_restore('error_log');
+            unlink($file);
+        }
+    }
+
+    public function test_write_with_exception_context(): void
+    {
+        $writer = new ErrorLogWriter();
+
+        $file = tempnam(sys_get_temp_dir(), 'otel_errorlog_');
+        $this->assertNotFalse($file);
+
+        try {
+            ini_set('error_log', $file);
+            $exception = new \RuntimeException('boom');
+            $writer->write('error', 'failure occurred', ['exception' => $exception]);
+
+            $contents = file_get_contents($file);
+            $this->assertStringContainsString('failure occurred', $contents);
+            $this->assertStringContainsString('boom', $contents);
+        } finally {
+            ini_restore('error_log');
+            unlink($file);
+        }
+    }
+}

tests/Unit/API/Behavior/Internal/LogWriter/NoopLogWriterTest.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Unit\API\Behavior\Internal\LogWriter;
+
+use OpenTelemetry\API\Behavior\Internal\LogWriter\NoopLogWriter;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(NoopLogWriter::class)]
+final class NoopLogWriterTest extends TestCase
+{
+    public function test_write_does_nothing(): void
+    {
+        $writer = new NoopLogWriter();
+
+        // Should not throw or produce any side effects
+        $writer->write('info', 'this message is discarded', []);
+        $writer->write('error', 'this too', ['exception' => new \RuntimeException('ignored')]);
+
+        $this->assertTrue(true);
+    }
+}

tests/Unit/API/Behavior/Internal/LogWriter/Psr3LogWriterTest.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Unit\API\Behavior\Internal\LogWriter;
+
+use OpenTelemetry\API\Behavior\Internal\LogWriter\Psr3LogWriter;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+
+#[CoversClass(Psr3LogWriter::class)]
+final class Psr3LogWriterTest extends TestCase
+{
+    public function test_write_delegates_to_psr3_logger(): void
+    {
+        $logger = $this->createMock(LoggerInterface::class);
+        $logger->expects($this->once())
+            ->method('log')
+            ->with('warning', 'test message', ['key' => 'value']);
+
+        $writer = new Psr3LogWriter($logger);
+        $writer->write('warning', 'test message', ['key' => 'value']);
+    }
+
+    public function test_write_passes_level_through(): void
+    {
+        $logger = $this->createMock(LoggerInterface::class);
+        $logger->expects($this->once())
+            ->method('log')
+            ->with('error', 'error message', []);
+
+        $writer = new Psr3LogWriter($logger);
+        $writer->write('error', 'error message', []);
+    }
+
+    public function test_write_passes_context_with_exception(): void
+    {
+        $exception = new \RuntimeException('test exception');
+        $context = ['exception' => $exception, 'extra' => 'data'];
+
+        $logger = $this->createMock(LoggerInterface::class);
+        $logger->expects($this->once())
+            ->method('log')
+            ->with('critical', 'something broke', $context);
+
+        $writer = new Psr3LogWriter($logger);
+        $writer->write('critical', 'something broke', $context);
+    }
+}

tests/Unit/API/Behavior/Internal/LogWriter/StreamLogWriterTest.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Unit\API\Behavior\Internal\LogWriter;
+
+use OpenTelemetry\API\Behavior\Internal\LogWriter\StreamLogWriter;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(StreamLogWriter::class)]
+final class StreamLogWriterTest extends TestCase
+{
+    public function test_write_appends_to_stream(): void
+    {
+        $file = tempnam(sys_get_temp_dir(), 'otel_test_');
+        $this->assertNotFalse($file);
+
+        try {
+            $writer = new StreamLogWriter($file);
+            $writer->write('warning', 'test message', []);
+
+            $contents = file_get_contents($file);
+            $this->assertStringContainsString('test message', $contents);
+        } finally {
+            unlink($file);
+        }
+    }
+
+    public function test_constructor_throws_for_invalid_destination(): void
+    {
+        $this->expectException(\RuntimeException::class);
+        new StreamLogWriter('/nonexistent/path/that/should/not/exist/file.log');
+    }
+
+    public function test_write_with_exception_context(): void
+    {
+        $file = tempnam(sys_get_temp_dir(), 'otel_test_');
+        $this->assertNotFalse($file);
+
+        try {
+            $writer = new StreamLogWriter($file);
+            $exception = new \RuntimeException('test exception');
+            $writer->write('error', 'something failed', ['exception' => $exception]);
+
+            $contents = file_get_contents($file);
+            $this->assertStringContainsString('something failed', $contents);
+            $this->assertStringContainsString('test exception', $contents);
+        } finally {
+            unlink($file);
+        }
+    }
+}

tests/Unit/API/Behavior/Internal/LogWriterFactoryTest.php

@@ -53,4 +53,24 @@ public function test_psr3_log_destination(): void
         LoggerHolder::set($this->createMock(LoggerInterface::class));
         $this->assertInstanceOf(Psr3LogWriter::class, (new LogWriterFactory())->create());
     }
+
+    public function test_psr3_from_env_with_logger(): void
+    {
+        $this->setEnvironmentVariable('OTEL_PHP_LOG_DESTINATION', 'psr3');
+        LoggerHolder::set($this->createMock(LoggerInterface::class));
+        $this->assertInstanceOf(Psr3LogWriter::class, (new LogWriterFactory())->create());
+    }
+
+    public function test_psr3_from_env_without_logger_falls_back_to_error_log(): void
+    {
+        $this->setEnvironmentVariable('OTEL_PHP_LOG_DESTINATION', 'psr3');
+        $this->assertInstanceOf(ErrorLogWriter::class, (new LogWriterFactory())->create());
+    }
+
+    public function test_default_with_logger_uses_psr3(): void
+    {
+        LoggerHolder::set($this->createMock(LoggerInterface::class));
+        $this->setEnvironmentVariable('OTEL_PHP_LOG_DESTINATION', '');
+        $this->assertInstanceOf(Psr3LogWriter::class, (new LogWriterFactory())->create());
+    }
 }