Spiral\Tests\Session\SessionTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	216
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	testValueDestroy()	0	11	1
A	testValueRestart()	0	11	1
A	tearDown()	0	4	2
A	testValueNewID()	0	11	1
A	testResumeNewSession()	0	13	1
A	testValueAbort()	0	19	1
A	testSectionArrayAccess()	0	31	1
A	testResumeAndID()	0	19	1
A	testSection()	0	18	2
A	setUp()	0	16	1
A	testSignatures()	0	23	1
A	testSectionClear()	0	8	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Tests\Session;

use PHPUnit\Framework\TestCase;
use Spiral\Core\Container;
use Spiral\Files\Files;
use Spiral\Files\FilesInterface;
use Spiral\Session\Config\SessionConfig;
use Spiral\Session\Handler\FileHandler;
use Spiral\Session\SessionSectionInterface;
use Spiral\Session\Session;
use Spiral\Session\SessionFactory;
use Spiral\Session\SessionInterface;
use Spiral\Session\SessionSection;

class SessionTest extends TestCase
{

    /**
     * @var SessionFactory
     */
    private $factory;

    public function setUp(): void
    {
        $container = new Container();
        $container->bind(FilesInterface::class, Files::class);

        $container->bind(SessionInterface::class, Session::class);
        $container->bind(SessionSectionInterface::class, SessionSection::class);

        $this->factory = new SessionFactory(new SessionConfig([
            'lifetime' => 86400,
            'cookie'   => 'SID',
            'secure'   => false,
            'handler'  => new Container\Autowire(FileHandler::class, [
                'directory' => sys_get_temp_dir()
            ]),
        ]), $container);
    }

    public function tearDown(): void
    {
        if ((int)session_status() === PHP_SESSION_ACTIVE) {
            session_abort();
        }
    }

    public function testValueDestroy(): void
    {
        $session = $this->factory->initSession('sig');
        $session->getSection()->set('key', 'value');

        $this->assertSame('value', $session->getSection()->get('key'));

        $session->destroy();
        $session->resume();

        $this->assertNull($session->getSection()->get('key'));
    }


    public function testValueAbort(): void
    {
        $session = $this->factory->initSession('sig');
        $session->getSection()->set('key', 'value');

        $this->assertSame('value', $session->getSection()->get('key'));
        $id = $session->getID();

        $session->commit();

        $session = $this->factory->initSession('sig', $id);
        $this->assertSame('value', $session->getSection()->get('key'));
        $session->getSection()->set('key', 'value2');
        $this->assertSame('value2', $session->getSection()->get('key'));
        $session->abort();

        $session = $this->factory->initSession('sig', $id);
        $this->assertSame('value', $session->getSection()->get('key'));
        $session->destroy();
    }

    public function testValueRestart(): void
    {
        $session = $this->factory->initSession('sig');
        $session->getSection()->set('key', 'value');

        $this->assertSame('value', $session->getSection()->get('key'));
        $id = $session->getID();
        $session->commit();

        $session = $this->factory->initSession('sig', $id);
        $this->assertSame('value', $session->getSection()->get('key'));
    }

    public function testValueNewID(): void
    {
        $session = $this->factory->initSession('sig');
        $session->getSection()->set('key', 'value');

        $this->assertSame('value', $session->getSection()->get('key'));
        $id = $session->regenerateID()->getID();
        $session->commit();

        $session = $this->factory->initSession('sig', $id);
        $this->assertSame('value', $session->getSection()->get('key'));
    }

    public function testSection(): void
    {
        $session = $this->factory->initSession('sig');
        $section = $session->getSection('default');

        $this->assertSame('default', $section->getName());

        $section->set('key', 'value');
        foreach ($section as $key => $value) {
            $this->assertSame('key', $key);
            $this->assertSame('value', $value);
        }

        $this->assertSame('key', $key);

The variable $key seems to be defined by a foreach iteration on line 128. Are you sure the iterator is never empty, otherwise this variable is not defined?

        $this->assertSame('value', $value);

The variable $value seems to be defined by a foreach iteration on line 128. Are you sure the iterator is never empty, otherwise this variable is not defined?

        $this->assertSame('value', $section->pull('key'));
        $this->assertNull($section->pull('key'));
    }

    public function testSectionClear(): void
    {
        $session = $this->factory->initSession('sig');
        $section = $session->getSection('default');

        $section->set('key', 'value');
        $section->clear();
        $this->assertNull($section->pull('key'));
    }

    public function testSectionArrayAccess(): void
    {
        $session = $this->factory->initSession('sig');
        $section = $session->getSection('default');

        $section['key'] = 'value';
        $this->assertSame('value', $section['key']);
        $section->key = 'new value';

Accessing key on the interface Spiral\Session\SessionSectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        $this->assertSame('new value', $section->key);
        $this->assertTrue(isset($section['key']));
        $this->assertTrue(isset($section->key));

        $section->delete('key');
        $this->assertFalse(isset($section['key']));
        $this->assertFalse(isset($section->key));

        $section->key = 'new value';
        unset($section->key);
        $this->assertFalse(isset($section->key));


        $section->key = 'new value';
        unset($section['key']);
        $this->assertFalse(isset($section->key));

        $section->new = 'another';

Accessing new on the interface Spiral\Session\SessionSectionInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        $session->commit();

        $this->assertNull($section->get('key'));
        $this->assertSame('another', $section->get('new'));
    }

    public function testResumeAndID(): void
    {
        $session = $this->factory->initSession('sig');
        $session->resume();
        $id = $session->getID();

        $this->assertTrue($session->isStarted());
        $session->commit();

        $this->assertFalse($session->isStarted());
        $this->assertSame($id, $session->getID());
        $this->assertFalse($session->isStarted());

        $session->destroy();
        $this->assertSame($id, $session->getID());

        $this->assertSame($id, $session->__debugInfo()['id']);

The method __debugInfo() does not exist on Spiral\Session\SessionInterface. It seems like you code against a sub-type of Spiral\Session\SessionInterface such as Spiral\Session\Session.

        $session->regenerateID();
        $this->assertNotSame($id, $session->getID());
    }

    public function testResumeNewSession(): void
    {
        $session = $this->factory->initSession('sig');
        $session->resume();
        $id = $session->getID();

        $this->assertTrue($session->isStarted());
        $session->commit();

        $session = $this->factory->initSession('sig');
        $session->resume();

        $this->assertNotSame($id, $session->getID());
    }

    public function testSignatures(): void
    {
        $session = $this->factory->initSession('sig');
        $session->getSection()->set('key', 'value');
        $session->commit();

        $id = $session->getID();

        $session = $this->factory->initSession('sig', $id);
        $this->assertSame('value', $session->getSection()->get('key'));
        $this->assertSame($id, $session->getID());
        $session->commit();

        $session = $this->factory->initSession('different', $id);
        $this->assertNull($session->getSection()->get('key'));
        $this->assertNotSame($id, $session->getID());
        $session->commit();

        // must be dead
        $session = $this->factory->initSession('sig', $id);
        $this->assertNull($session->getSection()->get('key'));
        $this->assertNotSame($id, $session->getID());
        $session->commit();
    }
}