PSR7SessionsTest\Storageless\Session\LazySessionTest

Complexity

Total Complexity

12

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

<?php
 * @covers \PSR7Sessions\Storageless\Session\LazySession
 */
final class LazySessionTest extends TestCase
{
    /** @var SessionInterface&MockObject */
    private SessionInterface $wrappedSession;

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected T_STRING, expecting T_FUNCTION or T_CONST

    /** @var callable&MockObject */
    private MockObject $sessionLoader;

    private LazySession $lazySession;

    protected function setUp() : void
    {
        $this->wrappedSession = $this->createMock(SessionInterface::class);
        $sessionLoader        = $this->getMockBuilder(stdClass::class)->setMethods(['__invoke'])->getMock();
        assert(is_callable($sessionLoader));
        $this->sessionLoader = $sessionLoader;
        $this->lazySession   = LazySession::fromContainerBuildingCallback($this->sessionLoader);
    }

    public function testLazyNonInitializedSessionIsAlwaysNotChanged() : void
    {
        $this->sessionLoader->expects(self::never())->method('__invoke');

        self::assertFalse($this->lazySession->hasChanged());
    }

    public function testHasChanged() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::at(1))->method('hasChanged')->willReturn(true);
        $this->wrappedSession->expects(self::at(2))->method('hasChanged')->willReturn(false);

        $this->forceWrappedSessionInitialization();

        self::assertTrue($this->lazySession->hasChanged());
        self::assertFalse($this->lazySession->hasChanged());
    }

    public function testHas() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::exactly(2))->method('has')->willReturnMap([
            ['foo', false],
            ['bar', true],
        ]);

        self::assertFalse($this->lazySession->has('foo'));
        self::assertTrue($this->lazySession->has('bar'));
    }

    public function testGet() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::exactly(3))->method('get')->willReturnMap([
            ['foo', null, 'bar'],
            ['baz', null, 'tab'],
            ['baz', 'default', 'taz'],
        ]);

        self::assertSame('bar', $this->lazySession->get('foo'));
        self::assertSame('tab', $this->lazySession->get('baz'));
        self::assertSame('taz', $this->lazySession->get('baz', 'default'));
    }

    public function testRemove() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::exactly(2))->method('remove')->with(self::logicalOr('foo', 'bar'));

        $this->lazySession->remove('foo');
        $this->lazySession->remove('bar');
    }

    public function testClear() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::exactly(2))->method('clear');

        $this->lazySession->clear();
        $this->lazySession->clear();
    }

    public function testSet() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this
            ->wrappedSession
            ->expects(self::exactly(2))
            ->method('set')
            ->with(self::logicalOr('foo', 'baz'), self::logicalOr('bar', 'tab'));

        $this->lazySession->set('foo', 'bar');
        $this->lazySession->set('baz', 'tab');
    }

    public function testIsEmpty() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::at(0))->method('isEmpty')->willReturn(true);
        $this->wrappedSession->expects(self::at(1))->method('isEmpty')->willReturn(false);

        self::assertTrue($this->lazySession->isEmpty());
        self::assertFalse($this->lazySession->isEmpty());
    }

    public function testJsonSerialize() : void
    {
        $this->wrappedSessionWillBeLoaded();

        $this->wrappedSession->expects(self::at(0))->method('jsonSerialize')->willReturn((object) ['foo' => 'bar']);
        $this->wrappedSession->expects(self::at(1))->method('jsonSerialize')->willReturn((object) ['baz' => 'tab']);

        self::assertEquals((object) ['foo' => 'bar'], $this->lazySession->jsonSerialize());
        self::assertEquals((object) ['baz' => 'tab'], $this->lazySession->jsonSerialize());
    }

    private function wrappedSessionWillBeLoaded() : void
    {
        $this->sessionLoader->expects(self::once())->method('__invoke')->willReturn($this->wrappedSession);
    }

    private function forceWrappedSessionInitialization() : void
    {
        // no-op operation that is known to trigger session lazy-loading
        $this->lazySession->remove(uniqid('nonExisting', true));
    }
}