TASK: Increase test coverage

and add code annotations to satisfy linter

Author: bwaidelich

.github/workflows/php.yml

@@ -23,6 +23,7 @@ jobs:
       uses: shivammathur/setup-php@v2
       with:
         php-version: ${{ matrix.php-versions }}
+        coverage: xdebug
 
     - name: Checkout code
       uses: actions/checkout@v3
@@ -44,3 +45,6 @@ jobs:
 
     - name: Run test suite
       run: composer run-script test
+
+    - name: Check code coverage (100% required)
+      run: composer run-script test:unit:coverage:check

check-coverage.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * Check code coverage and fail if below 100%
+ */
+
+$coverageFile = __DIR__ . '/coverage.xml';
+
+if (!file_exists($coverageFile)) {
+    echo "Coverage file not found: {$coverageFile}\n";
+    echo "Run: composer run-script test:unit:coverage\n";
+    exit(1);
+}
+
+$xml = simplexml_load_string(file_get_contents($coverageFile));
+if ($xml === false) {
+    echo "Failed to parse coverage file\n";
+    exit(1);
+}
+
+$metrics = $xml->project->metrics;
+$statements = (int) $metrics['statements'];
+$coveredStatements = (int) $metrics['coveredstatements'];
+
+if ($statements === 0) {
+    echo "No statements found in coverage report\n";
+    exit(1);
+}
+
+$coverage = ($coveredStatements / $statements) * 100;
+
+if ($coverage < 100) {
+    echo sprintf(
+        "✗ Code coverage is %.2f%%, which is below the required 100%%\n",
+        $coverage,
+    );
+    echo sprintf(
+        "  Covered: %d/%d statements\n",
+        $coveredStatements,
+        $statements,
+    );
+    exit(1);
+}
+
+echo sprintf("✓ Code coverage is 100%% (%d/%d statements)\n", $coveredStatements, $statements);
+exit(0);

composer.json

@@ -44,8 +44,13 @@
     "test:phpstan": "phpstan",
     "test:cs": "vendor/bin/php-cs-fixer check",
     "test:cs:fix": "vendor/bin/php-cs-fixer fix",
-    "test:unit": "phpunit tests/Unit",
-    "test:integration": "phpunit tests/Integration --exclude-group=feature_liveStream",
+    "test:unit": "phpunit tests/Unit --no-coverage",
+    "test:unit:coverage": "php -d xdebug.mode=coverage vendor/bin/phpunit tests/Unit --coverage-text --coverage-clover=coverage.xml --coverage-filter=src",
+    "test:unit:coverage:check": [
+      "@test:unit:coverage",
+      "@php check-coverage.php"
+    ],
+    "test:integration": "phpunit tests/Integration --exclude-group=feature_liveStream --no-coverage",
     "test": [
       "@test:phpstan",
       "@test:cs",

phpunit.xml

@@ -1,21 +1,25 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.1/phpunit.xsd"
+         xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/11.5/phpunit.xsd"
          bootstrap="vendor/autoload.php"
          cacheDirectory=".phpunit.cache"
          executionOrder="depends,defects"
          requireCoverageMetadata="true"
-         beStrictAboutCoverageMetadata="true"
          beStrictAboutOutputDuringTests="true"
-         failOnRisky="true"
-         failOnWarning="true">
+         failOnRisky="true">
     <testsuites>
         <testsuite name="default">
             <directory>tests</directory>
         </testsuite>
     </testsuites>
 
-    <coverage includeUncoveredFiles="false"></coverage>
+    <coverage includeUncoveredFiles="true"
+              ignoreDeprecatedCodeUnits="true"
+              disableCodeCoverageIgnore="false">
+        <report>
+            <text outputFile="php://stdout"/>
+        </report>
+    </coverage>
 
     <source restrictDeprecations="true" restrictNotices="true" restrictWarnings="true">
         <include>

src/Query/QueryItem.php

@@ -72,6 +72,8 @@ public function with(
 
     public function canBeMerged(self $other): bool
     {
+        /** @noinspection TypeUnsafeComparisonInspection */
+        /** @noinspection PhpNonStrictObjectEqualityInspection */
         return $this->onlyLastEvent === $other->onlyLastEvent && $this->tags == $other->tags;
     }
 
@@ -80,6 +82,8 @@ public function merge(self $other): self
         if ($this->onlyLastEvent !== $other->onlyLastEvent) {
             throw new InvalidArgumentException('Query items with different values for "onlyLasEvent" flag cannot be merged');
         }
+        /** @noinspection TypeUnsafeComparisonInspection */
+        /** @noinspection PhpNonStrictObjectEqualityInspection */
         if ($this->tags != $other->tags) {
             throw new InvalidArgumentException('Query items with tag mismatch cannot be merged');
         }

src/SequencedEvent/SequencedEvents.php

@@ -64,6 +64,7 @@ public function first(): SequencedEvent|null
         if ($this->first !== null) {
             return $this->first;
         }
+        /** @noinspection LoopWhichDoesNotLoopInspection */
         foreach ($this as $sequencedEvent) {
             return $sequencedEvent;
         }

tests/Unit/AppendCondition/AppendConditionTest.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Unit\AppendCondition;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Medium;
+use PHPUnit\Framework\TestCase;
+use Wwwision\DCBEventStore\AppendCondition\AppendCondition;
+use Wwwision\DCBEventStore\Query\Query;
+use Wwwision\DCBEventStore\Query\QueryItem;
+use Wwwision\DCBEventStore\SequencedEvent\SequencePosition;
+
+#[CoversClass(AppendCondition::class)]
+#[Medium]
+final class AppendConditionTest extends TestCase
+{
+    public function test_constructor_sets_properties(): void
+    {
+        $query = Query::fromItems(QueryItem::create(eventTypes: 'SomeType'));
+        $position = SequencePosition::fromInteger(10);
+
+        $condition = new AppendCondition($query, $position);
+
+        self::assertSame($query, $condition->failIfEventsMatch);
+        self::assertSame($position, $condition->after);
+    }
+
+    public function test_constructor_with_null_after(): void
+    {
+        $query = Query::fromItems(QueryItem::create(tags: 'some-tag'));
+
+        $condition = new AppendCondition($query, null);
+
+        self::assertSame($query, $condition->failIfEventsMatch);
+        self::assertNull($condition->after);
+    }
+
+    public function test_properties_are_readonly(): void
+    {
+        $query = Query::fromItems(QueryItem::create(eventTypes: 'TestType'));
+        $position = SequencePosition::fromInteger(5);
+
+        $condition = new AppendCondition($query, $position);
+
+        self::assertSame($query, $condition->failIfEventsMatch);
+        self::assertSame($position, $condition->after);
+    }
+}

tests/Unit/Event/EventDataTest.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Unit\Event;
+
+use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Medium;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+use Wwwision\DCBEventStore\Event\EventData;
+
+#[Medium]
+#[CoversClass(EventData::class)]
+final class EventDataTest extends TestCase
+{
+    public function test_fromString_allows_empty_string(): void
+    {
+        $eventData = EventData::fromString('');
+        self::assertSame('', $eventData->value);
+    }
+
+    public function test_jsonDecode_fails_if_data_is_no_valid_json(): void
+    {
+        $eventData = EventData::fromString('not json');
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Failed to JSON-decode event data: Syntax error');
+        $eventData->jsonDecode();
+    }
+
+    public function test_jsonDecode_fails_if_data_is_no_json_array(): void
+    {
+        $eventData = EventData::fromString('true');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Expected an array. Got: boolean');
+        $eventData->jsonDecode();
+    }
+
+    public function test_jsonDecode_returns_encoded_array_data(): void
+    {
+        $data = ['foo' => 'bar', 'bar' => ['baz' => true, 'foos' => 123.45]];
+        $dataJson = json_encode($data, JSON_THROW_ON_ERROR);
+        self::assertIsString($dataJson);
+        $result = EventData::fromString($dataJson)->jsonDecode();
+        self::assertSame($data, $result);
+    }
+
+    public function test_json_represents_value(): void
+    {
+        $eventData = EventData::fromString('input');
+        self::assertSame('"input"', json_encode($eventData, JSON_THROW_ON_ERROR));
+    }
+}

tests/Unit/Event/EventMetadataTest.php

@@ -17,12 +17,26 @@ public function test_none_creates_empty_instance(): void
         self::assertSame([], EventMetadata::none()->value);
     }
 
+    public function test_fromArray_creates_instance_from_associative_array(): void
+    {
+        $metadata = EventMetadata::fromArray(['key1' => 'value1', 'key2' => 'value2']);
+
+        self::assertSame(['key1' => 'value1', 'key2' => 'value2'], $metadata->value);
+    }
+
     public function test_fromArray_fails_if_array_is_not_associative(): void
     {
         $this->expectException(InvalidArgumentException::class);
         EventMetadata::fromArray(['foo', 'bar']);
     }
 
+    public function test_fromJson_creates_instance_from_valid_json(): void
+    {
+        $metadata = EventMetadata::fromJson('{"key1": "value1", "key2": "value2"}');
+
+        self::assertSame(['key1' => 'value1', 'key2' => 'value2'], $metadata->value);
+    }
+
     public function test_fromJson_fails_if_value_is_no_valid_json(): void
     {
         $this->expectException(InvalidArgumentException::class);

tests/Unit/Event/EventTypeTest.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Unit\Event;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Medium;
+use PHPUnit\Framework\TestCase;
+use Wwwision\DCBEventStore\Event\EventType;
+
+#[Medium]
+#[CoversClass(EventType::class)]
+final class EventTypeTest extends TestCase
+{
+    public function test_equal_returns_true_if_event_types_match(): void
+    {
+        $eventType1 = EventType::fromString('some-type');
+        $eventType2 = EventType::fromString('some-type');
+        self::assertTrue($eventType1->equals($eventType2));
+    }
+
+    public function test_equal_returns_false_if_event_types_do_not_match(): void
+    {
+        $eventType1 = EventType::fromString('some-type');
+        $eventType2 = EventType::fromString('Some-Type');
+        self::assertFalse($eventType1->equals($eventType2));
+    }
+
+    public function test_jsonSerialize_returns_string_value(): void
+    {
+        $eventType = EventType::fromString('TestType');
+
+        self::assertSame('TestType', $eventType->jsonSerialize());
+    }
+}