dbal/tests/Types/DateIntervalTest.php at 9e5c40af7a808c724e640584be50c26ef288030f · derrabus/dbal · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
<?php

declare(strict_types=1);

namespace Doctrine\DBAL\Tests\Types;

use DateInterval;
use DateTime;
use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\ConversionException;
use Doctrine\DBAL\Types\DateIntervalType;
use Override;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\TestCase;
use stdClass;

final class DateIntervalTest extends TestCase
{
    private AbstractPlatform&Stub $platform;
    private DateIntervalType $type;

    #[Override]
    protected function setUp(): void
    {
        $this->platform = self::createStub(AbstractPlatform::class);
        $this->type     = new DateIntervalType();
    }

    public function testDateIntervalConvertsToDatabaseValue(): void
    {
        $interval = new DateInterval('P2Y1DT1H2M3S');

        $expected = '+P02Y00M01DT01H02M03S';
        $actual   = $this->type->convertToDatabaseValue($interval, $this->platform);

        self::assertEquals($expected, $actual);
    }

    public function testDateIntervalConvertsToPHPValue(): void
    {
        $interval = $this->type->convertToPHPValue('+P02Y00M01DT01H02M03S', $this->platform);

        self::assertInstanceOf(DateInterval::class, $interval);
        self::assertEquals('+P02Y00M01DT01H02M03S', $interval->format(DateIntervalType::FORMAT));
    }

    public function testNegativeDateIntervalConvertsToDatabaseValue(): void
    {
        $interval         = new DateInterval('P2Y1DT1H2M3S');
        $interval->invert = 1;

        $actual = $this->type->convertToDatabaseValue($interval, $this->platform);

        self::assertEquals('-P02Y00M01DT01H02M03S', $actual);
    }

    public function testNegativeDateIntervalConvertsToPHPValue(): void
    {
        $interval = $this->type->convertToPHPValue('-P02Y00M01DT01H02M03S', $this->platform);

        self::assertInstanceOf(DateInterval::class, $interval);
        self::assertEquals('-P02Y00M01DT01H02M03S', $interval->format(DateIntervalType::FORMAT));
    }

    public function testDateIntervalFormatWithoutSignConvertsToPHPValue(): void
    {
        $interval = $this->type->convertToPHPValue('P02Y00M01DT01H02M03S', $this->platform);

        self::assertInstanceOf(DateInterval::class, $interval);
        self::assertEquals('+P02Y00M01DT01H02M03S', $interval->format(DateIntervalType::FORMAT));
    }

    public function testInvalidDateIntervalFormatConversion(): void
    {
        $this->expectException(ConversionException::class);

        $this->type->convertToPHPValue('abcdefg', $this->platform);
    }

    public function testDateIntervalNullConversion(): void
    {
        self::assertNull($this->type->convertToPHPValue(null, $this->platform));
    }

    public function testDateIntervalEmptyStringConversion(): void
    {
        $this->expectException(ConversionException::class);

        $this->type->convertToPHPValue('', $this->platform);
    }

    #[DataProvider('invalidPHPValuesProvider')]
    public function testInvalidTypeConversionToDatabaseValue(mixed $value): void
    {
        $this->expectException(ConversionException::class);

        $this->type->convertToDatabaseValue($value, $this->platform);
    }

    /** @return mixed[][] */
    public static function invalidPHPValuesProvider(): iterable
    {
        return [
            [0],
            [''],
            ['foo'],
            ['10:11:12'],
            ['2015-01-31'],
            ['2015-01-31 10:11:12'],
            [new stdClass()],
            [27],
            [-1],
            [1.2],
            [[]],
            [['an array']],
            [new DateTime()],
        ];
    }
}