Initial Release

tests/Clock/FrozenClockTest.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock\Tests;
+
+use Beste\Clock\FrozenClock;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+use Psr\Clock\ClockInterface;
+
+/**
+ * @internal
+ * @coversDefaultClass \Beste\Clock\FrozenClock
+ */
+final class FrozenClockTest extends TestCase
+{
+    /**
+     * @test
+     * @covers ::__construct
+     * @covers ::at
+     * @covers ::now
+     */
+    public function itFreezesTime(): void
+    {
+        $now = new DateTimeImmutable('2021-03-21 22:16:00');
+        $clock = FrozenClock::at($now);
+
+        self::assertEquals($now, $clock->now());
+    }
+
+    /**
+     * @test
+     *
+     * @uses \Beste\Clock\FrozenClock::__construct
+     * @uses \Beste\Clock\FrozenClock::fromUTC()
+     *
+     * @covers ::now()
+     */
+    public function itReturnsAnEqualNowButNotTheSame(): void
+    {
+        $clock = FrozenClock::fromUTC();
+
+        $first = $clock->now();
+        $second = $clock->now();
+
+        self::assertEquals($first, $second);
+        self::assertNotSame($first, $second);
+    }
+
+    /**
+     * @test
+     *
+     * @uses \Beste\Clock\FrozenClock::__construct
+     * @uses \Beste\Clock\FrozenClock::now
+     *
+     * @covers ::withNowFrom
+     */
+    public function itFreezesTimeFromAnotherClock(): void
+    {
+        $now = new DateTimeImmutable('now');
+
+        $clock = $this->createMock(ClockInterface::class);
+        $clock
+            ->expects(self::once())
+            ->method('now')
+            ->willReturn($now);
+
+        $frozenClock = FrozenClock::withNowFrom($clock);
+
+        self::assertEquals($now, $frozenClock->now());
+    }
+
+    /**
+     * @test
+     *
+     * @uses \Beste\Clock\FrozenClock::__construct
+     * @uses \Beste\Clock\FrozenClock::now
+     *
+     * @covers ::fromUTC
+     */
+    public function itFreezesTheCurrentUTCTime(): void
+    {
+        $clock = FrozenClock::fromUTC();
+
+        self::assertSame('UTC', $clock->now()->getTimezone()->getName());
+        self::assertEquals($clock->now(), $clock->now());
+    }
+
+    /**
+     * @test
+     *
+     * @uses \Beste\Clock\FrozenClock::__construct
+     * @uses \Beste\Clock\FrozenClock::at
+     * @uses \Beste\Clock\FrozenClock::now
+     *
+     * @covers ::setTo
+     */
+    public function itCanBeSet(): void
+    {
+        $now = new DateTimeImmutable('2021-03-21 18:18:18');
+        $then = new DateTimeImmutable('2021-03-21 19:19:19');
+
+        $clock = FrozenClock::at($now);
+        $clock->setTo($then);
+
+        self::assertEquals($then, $clock->now());
+    }
+}

tests/Clock/LocalizedClockTest.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock\Tests;
+
+use Beste\Clock\LocalizedClock;
+use DateTimeZone;
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ * @coversDefaultClass \Beste\Clock\LocalizedClock
+ */
+final class LocalizedClockTest extends TestCase
+{
+    /**
+     * @test
+     * @covers ::in
+     */
+    public function itRejectsAnInvalidTimeZone(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        LocalizedClock::in('invalid');
+    }
+
+    /**
+     * @test
+     * @covers ::__construct
+     * @covers ::in
+     * @covers ::now
+     */
+    public function itUsesTheGivenTimeZone(): void
+    {
+        $timeZone = new DateTimeZone('Asia/Bangkok');
+        $clock = LocalizedClock::in($timeZone);
+        $now = $clock->now();
+
+        self::assertSame($timeZone->getName(), $now->getTimezone()->getName());
+    }
+
+    /**
+     * @test
+     * @covers ::__construct
+     * @covers ::in
+     * @covers ::now
+     */
+    public function itAcceptsTheTimeZoneAsAString(): void
+    {
+        $timeZone = 'Pacific/Guam';
+        $clock = LocalizedClock::in($timeZone);
+        $now = $clock->now();
+
+        self::assertSame($timeZone, $now->getTimezone()->getName());
+    }
+}

tests/Clock/MinuteClockTest.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock\Tests;
+
+use Beste\Clock\MinuteClock;
+use DateTimeImmutable;
+use PHPUnit\Framework\TestCase;
+use Psr\Clock\ClockInterface;
+
+/**
+ * @internal
+ * @coversDefaultClass \Beste\Clock\MinuteClock
+ */
+final class MinuteClockTest extends TestCase
+{
+    /**
+     * @test
+     *
+     * @covers ::__construct
+     * @covers ::wrapping
+     * @covers ::now
+     * @covers ::floor
+     *
+     * @uses \Beste\Clock\FrozenClock
+     *
+     * @dataProvider dateTimeStringProvider
+     */
+    public function itDiscardsEverythingSmallerThanMinutes(string $format, string $input, string $expected): void
+    {
+        $mockClock = $this->createMock(ClockInterface::class);
+        $mockClock->method('now')->willReturn(new DateTimeImmutable($input));
+
+        // Just to be sure that the test input is valid ^^
+        self::assertSame($input, $mockClock->now()->format($format));
+
+        $clock = MinuteClock::wrapping($mockClock);
+
+        self::assertSame($expected, $clock->now()->format($format));
+    }
+
+    /**
+     * @return array<string, string[]>
+     */
+    public function dateTimeStringProvider(): array
+    {
+        return [
+            'microseconds' => [
+                'Y-m-d H:i:s.u',
+                '2021-03-24 01:23:45.123456',
+                '2021-03-24 01:23:00.000000',
+            ],
+            'milliseconds' => [
+                'Y-m-d H:i:s.v',
+                '2021-03-24 01:23:45.123',
+                '2021-03-24 01:23:00.000',
+            ],
+            'seconds' => [
+                'Y-m-d H:i:s',
+                '2021-03-24 01:23:45',
+                '2021-03-24 01:23:00',
+            ],
+        ];
+    }
+}

tests/Clock/SystemClockTest.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock\Tests;
+
+use Beste\Clock\SystemClock;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ * @coversDefaultClass \Beste\Clock\SystemClock
+ */
+final class SystemClockTest extends TestCase
+{
+    private string $defaultTimeZone;
+
+    protected function setUp(): void
+    {
+        $this->defaultTimeZone = date_default_timezone_get();
+    }
+
+    protected function tearDown(): void
+    {
+        date_default_timezone_set($this->defaultTimeZone);
+    }
+
+    /**
+     * @test
+     *
+     * @covers ::__construct
+     * @covers ::create
+     * @covers ::now
+     */
+    public function itUsesTheSystemTimeZone(): void
+    {
+        $timeZone = 'Europe/Berlin';
+        self::assertNotSame($timeZone, $this->defaultTimeZone);
+
+        date_default_timezone_set($timeZone);
+
+        $clock = SystemClock::create();
+        $now = $clock->now();
+
+        self::assertSame($timeZone, $now->getTimezone()->getName());
+    }
+}

tests/Clock/UTCClockTest.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock\Tests;
+
+use Beste\Clock\UTCClock;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * @internal
+ * @coversDefaultClass \Beste\Clock\UTCClock
+ */
+final class UTCClockTest extends TestCase
+{
+    private string $defaultTimeZone;
+
+    protected function setUp(): void
+    {
+        $this->defaultTimeZone = date_default_timezone_get();
+    }
+
+    protected function tearDown(): void
+    {
+        date_default_timezone_set($this->defaultTimeZone);
+    }
+
+    /**
+     * @test
+     *
+     * @covers ::__construct
+     * @covers ::create
+     * @covers ::now
+     */
+    public function itUsesUTCRegardlessOfTheSystemTimeZone(): void
+    {
+        date_default_timezone_set('Europe/Berlin');
+
+        $clock = UTCClock::create();
+        $now = $clock->now();
+
+        self::assertSame('UTC', $now->getTimezone()->getName());
+    }
+}