Add more tests

Author: martin-georgiev

tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/BaseRangeTestCase.php

@@ -6,6 +6,8 @@
 
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use MartinGeorgiev\Doctrine\DBAL\Types\BaseRangeType;
+use MartinGeorgiev\Doctrine\DBAL\Types\Exceptions\InvalidRangeForDatabaseException;
+use MartinGeorgiev\Doctrine\DBAL\Types\Exceptions\InvalidRangeForPHPException;
 use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\Range;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Test;
@@ -93,6 +95,41 @@ public function can_handle_postgres_empty_range(): void
         self::assertTrue($result->isEmpty());
     }
 
+    #[Test]
+    public function can_handle_empty_string_from_sql(): void
+    {
+        $result = $this->fixture->convertToPHPValue('', $this->platform);
+
+        self::assertNull($result);
+    }
+
+    #[Test]
+    public function throws_exception_for_invalid_php_value_type(): void
+    {
+        $this->expectException(InvalidRangeForDatabaseException::class);
+        $this->expectExceptionMessage('Invalid type for range');
+
+        $this->fixture->convertToDatabaseValue('invalid', $this->platform); // @phpstan-ignore-line argument.type
+    }
+
+    #[Test]
+    public function throws_exception_for_invalid_sql_value_type(): void
+    {
+        $this->expectException(InvalidRangeForPHPException::class);
+        $this->expectExceptionMessage('Invalid database value type for range conversion');
+
+        $this->fixture->convertToPHPValue([1, 2], $this->platform); // @phpstan-ignore-line argument.type
+    }
+
+    #[Test]
+    public function throws_exception_for_invalid_range_format(): void
+    {
+        $this->expectException(InvalidRangeForPHPException::class);
+        $this->expectExceptionMessage('Invalid range format from database');
+
+        $this->fixture->convertToPHPValue('{1,2}', $this->platform);
+    }
+
     /**
      * Each array contains [phpValue, postgresValue] pairs.
      */

tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/BaseRangeTestCase.php

@@ -0,0 +1,288 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Unit\MartinGeorgiev\Doctrine\DBAL\Types\ValueObject;
+
+use MartinGeorgiev\Doctrine\DBAL\Types\ValueObject\Range;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
+
+abstract class BaseRangeTestCase extends TestCase
+{
+    #[Test]
+    public function can_create_simple_range(): void
+    {
+        $range = $this->createSimpleRange();
+        $expectedString = $this->getExpectedSimpleRangeString();
+
+        self::assertEquals($expectedString, (string) $range);
+        self::assertFalse($range->isEmpty());
+    }
+
+    #[Test]
+    public function can_create_empty_range(): void
+    {
+        $range = $this->createEmptyRange();
+
+        self::assertEquals('empty', (string) $range);
+        self::assertTrue($range->isEmpty());
+    }
+
+    #[Test]
+    public function can_create_infinite_range(): void
+    {
+        $range = $this->createInfiniteRange();
+
+        self::assertEquals('(,)', (string) $range);
+        self::assertFalse($range->isEmpty());
+    }
+
+    #[Test]
+    public function can_create_inclusive_range(): void
+    {
+        $range = $this->createInclusiveRange();
+        $expectedString = $this->getExpectedInclusiveRangeString();
+
+        self::assertEquals($expectedString, (string) $range);
+        self::assertFalse($range->isEmpty());
+    }
+
+    #[Test]
+    #[DataProvider('provideContainsTestCases')]
+    public function can_check_contains(Range $range, mixed $value, bool $expected): void
+    {
+        self::assertEquals($expected, $range->contains($value));
+    }
+
+    #[Test]
+    #[DataProvider('provideFromStringTestCases')]
+    public function can_parse_from_string(string $input, Range $expectedRange): void
+    {
+        $range = $this->parseFromString($input);
+        $this->assertRangeEquals($expectedRange, $range);
+    }
+
+    #[Test]
+    public function can_handle_boundary_conditions(): void
+    {
+        $range = $this->createBoundaryTestRange();
+        $testCases = $this->getBoundaryTestCases();
+
+        $this->assertBoundaryConditions($range, $testCases);
+    }
+
+    #[Test]
+    public function can_handle_comparison_via_is_empty(): void
+    {
+        $testCases = $this->getComparisonTestCases();
+
+        foreach ($testCases as $description => $testCase) {
+            self::assertEquals(
+                $testCase['expectedEmpty'],
+                $testCase['range']->isEmpty(),
+                'Comparison test failed: '.$description
+            );
+        }
+    }
+
+    /**
+     * Create a simple range for basic testing.
+     */
+    abstract protected function createSimpleRange(): Range;
+
+    /**
+     * Get expected string representation of simple range.
+     */
+    abstract protected function getExpectedSimpleRangeString(): string;
+
+    /**
+     * Create an empty range.
+     */
+    abstract protected function createEmptyRange(): Range;
+
+    /**
+     * Create an infinite range.
+     */
+    abstract protected function createInfiniteRange(): Range;
+
+    /**
+     * Create an inclusive range for testing.
+     */
+    abstract protected function createInclusiveRange(): Range;
+
+    /**
+     * Get expected string representation of inclusive range.
+     */
+    abstract protected function getExpectedInclusiveRangeString(): string;
+
+    /**
+     * Parse range from string.
+     */
+    abstract protected function parseFromString(string $input): Range;
+
+    /**
+     * Create range for boundary testing.
+     */
+    abstract protected function createBoundaryTestRange(): Range;
+
+    /**
+     * Get boundary test cases.
+     *
+     * @return array<string, array{value: mixed, expected: bool}>
+     */
+    abstract protected function getBoundaryTestCases(): array;
+
+    /**
+     * Get comparison test cases.
+     *
+     * @return array<string, array{range: Range, expectedEmpty: bool}>
+     */
+    abstract protected function getComparisonTestCases(): array;
+
+    /**
+     * @return \Generator<string, array{Range, mixed, bool}>
+     */
+    abstract public static function provideContainsTestCases(): \Generator;
+
+    /**
+     * @return \Generator<string, array{string, Range}>
+     */
+    abstract public static function provideFromStringTestCases(): \Generator;
+
+    /**
+     * Assert that a range equals another range by comparing string representation and isEmpty state.
+     */
+    protected function assertRangeEquals(Range $expected, Range $actual, string $message = ''): void
+    {
+        self::assertEquals($expected->__toString(), $actual->__toString(), $message.' (string representation)');
+        self::assertEquals($expected->isEmpty(), $actual->isEmpty(), $message.' (isEmpty state)');
+    }
+
+    /**
+     * Assert that a range contains all the given values.
+     *
+     * @param array<mixed> $values
+     */
+    protected function assertRangeContainsAll(Range $range, array $values, string $message = ''): void
+    {
+        foreach ($values as $value) {
+            self::assertTrue(
+                $range->contains($value),
+                $message.' - Range should contain value: '.\var_export($value, true)
+            );
+        }
+    }
+
+    /**
+     * Assert that a range does not contain any of the given values.
+     *
+     * @param array<mixed> $values
+     */
+    protected function assertRangeContainsNone(Range $range, array $values, string $message = ''): void
+    {
+        foreach ($values as $value) {
+            self::assertFalse(
+                $range->contains($value),
+                $message.' - Range should not contain value: '.\var_export($value, true)
+            );
+        }
+    }
+
+    /**
+     * Assert that a range has the expected string representation.
+     */
+    protected function assertRangeStringEquals(string $expected, Range $range, string $message = ''): void
+    {
+        self::assertEquals($expected, (string) $range, $message);
+    }
+
+    /**
+     * Assert that a range is empty.
+     */
+    protected function assertRangeIsEmpty(Range $range, string $message = ''): void
+    {
+        self::assertTrue($range->isEmpty(), $message.' - Range should be empty');
+        self::assertEquals('empty', (string) $range, $message.' - Empty range should have "empty" string representation');
+    }
+
+    /**
+     * Assert that a range is not empty.
+     */
+    protected function assertRangeIsNotEmpty(Range $range, string $message = ''): void
+    {
+        self::assertFalse($range->isEmpty(), $message.' - Range should not be empty');
+        self::assertNotEquals('empty', (string) $range, $message.' - Non-empty range should not have "empty" string representation');
+    }
+
+    /**
+     * Test boundary conditions for a range with known bounds.
+     *
+     * @param array<string, array{value: mixed, expected: bool}> $testCases
+     */
+    protected function assertBoundaryConditions(Range $range, array $testCases, string $message = ''): void
+    {
+        foreach ($testCases as $description => $testCase) {
+            self::assertEquals(
+                $testCase['expected'],
+                $range->contains($testCase['value']),
+                $message.' - Boundary test failed: '.$description
+            );
+        }
+    }
+
+    /**
+     * Generate common boundary test cases for a range [lower, upper).
+     *
+     * @return array<string, array{value: mixed, expected: bool}>
+     */
+    protected function generateBoundaryTestCases(
+        mixed $lower,
+        mixed $upper,
+        mixed $belowLower,
+        mixed $aboveUpper,
+        mixed $middle
+    ): array {
+        return [
+            'contains lower bound (inclusive)' => ['value' => $lower, 'expected' => true],
+            'does not contain value below range' => ['value' => $belowLower, 'expected' => false],
+            'does not contain upper bound (exclusive)' => ['value' => $upper, 'expected' => false],
+            'does not contain value above range' => ['value' => $aboveUpper, 'expected' => false],
+            'contains middle value' => ['value' => $middle, 'expected' => true],
+            'does not contain null' => ['value' => null, 'expected' => false],
+        ];
+    }
+
+    /**
+     * Test that a range correctly handles equal bounds with different bracket combinations.
+     *
+     * @param callable $rangeFactory Function that creates a range: fn($lower, $upper, $lowerInc, $upperInc) => Range
+     */
+    protected function assertEqualBoundsHandling(callable $rangeFactory, mixed $value): void
+    {
+        $inclusiveEqual = $rangeFactory($value, $value, true, true);
+        self::assertFalse($inclusiveEqual->isEmpty(), 'Equal bounds with inclusive brackets should not be empty');
+        self::assertTrue($inclusiveEqual->contains($value), 'Equal bounds with inclusive brackets should contain the value');
+
+        $exclusiveExclusive = $rangeFactory($value, $value, false, false);
+        self::assertTrue($exclusiveExclusive->isEmpty(), 'Equal bounds with exclusive brackets should be empty');
+
+        $inclusiveExclusive = $rangeFactory($value, $value, true, false);
+        self::assertTrue($inclusiveExclusive->isEmpty(), 'Equal bounds with mixed brackets should be empty');
+
+        $exclusiveInclusive = $rangeFactory($value, $value, false, true);
+        self::assertTrue($exclusiveInclusive->isEmpty(), 'Equal bounds with mixed brackets should be empty');
+    }
+
+    /**
+     * Test that a range correctly handles reverse bounds (lower > upper).
+     *
+     * @param callable $rangeFactory Function that creates a range: fn($lower, $upper, $lowerInc, $upperInc) => Range
+     */
+    protected function assertReverseBoundsHandling(callable $rangeFactory, mixed $lower, mixed $upper): void
+    {
+        $reverseRange = $rangeFactory($lower, $upper, true, false);
+        self::assertTrue($reverseRange->isEmpty(), 'Range with lower > upper should be empty');
+    }
+}