You are here

class MockArraySessionStorage in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/symfony/http-foundation/Session/Storage/MockArraySessionStorage.php \Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage

MockArraySessionStorage mocks the session for unit tests.

No PHP session is actually started since a session can be initialized and shutdown only once per PHP execution cycle.

When doing functional testing, you should use MockFileSessionStorage instead.

@author Fabien Potencier <fabien@symfony.com> @author Bulat Shakirzyanov <mallluhuct@gmail.com> @author Drak <drak@zikula.org>

Hierarchy

Expanded class hierarchy of MockArraySessionStorage

3 files declare their use of MockArraySessionStorage
MockArraySessionStorageTest.php in vendor/symfony/http-foundation/Tests/Session/Storage/MockArraySessionStorageTest.php
RequestTest.php in vendor/symfony/http-foundation/Tests/RequestTest.php
SessionTest.php in vendor/symfony/http-foundation/Tests/Session/SessionTest.php

File

vendor/symfony/http-foundation/Session/Storage/MockArraySessionStorage.php, line 28

Namespace

Symfony\Component\HttpFoundation\Session\Storage
View source
class MockArraySessionStorage implements SessionStorageInterface {

  /**
   * @var string
   */
  protected $id = '';

  /**
   * @var string
   */
  protected $name;

  /**
   * @var bool
   */
  protected $started = false;

  /**
   * @var bool
   */
  protected $closed = false;

  /**
   * @var array
   */
  protected $data = array();

  /**
   * @var MetadataBag
   */
  protected $metadataBag;

  /**
   * @var array
   */
  protected $bags;

  /**
   * Constructor.
   *
   * @param string      $name    Session name
   * @param MetadataBag $metaBag MetadataBag instance.
   */
  public function __construct($name = 'MOCKSESSID', MetadataBag $metaBag = null) {
    $this->name = $name;
    $this
      ->setMetadataBag($metaBag);
  }

  /**
   * Sets the session data.
   *
   * @param array $array
   */
  public function setSessionData(array $array) {
    $this->data = $array;
  }

  /**
   * {@inheritdoc}
   */
  public function start() {
    if ($this->started) {
      return true;
    }
    if (empty($this->id)) {
      $this->id = $this
        ->generateId();
    }
    $this
      ->loadSession();
    return true;
  }

  /**
   * {@inheritdoc}
   */
  public function regenerate($destroy = false, $lifetime = null) {
    if (!$this->started) {
      $this
        ->start();
    }
    $this->metadataBag
      ->stampNew($lifetime);
    $this->id = $this
      ->generateId();
    return true;
  }

  /**
   * {@inheritdoc}
   */
  public function getId() {
    return $this->id;
  }

  /**
   * {@inheritdoc}
   */
  public function setId($id) {
    if ($this->started) {
      throw new \LogicException('Cannot set session ID after the session has started.');
    }
    $this->id = $id;
  }

  /**
   * {@inheritdoc}
   */
  public function getName() {
    return $this->name;
  }

  /**
   * {@inheritdoc}
   */
  public function setName($name) {
    $this->name = $name;
  }

  /**
   * {@inheritdoc}
   */
  public function save() {
    if (!$this->started || $this->closed) {
      throw new \RuntimeException('Trying to save a session that was not started yet or was already closed');
    }

    // nothing to do since we don't persist the session data
    $this->closed = false;
    $this->started = false;
  }

  /**
   * {@inheritdoc}
   */
  public function clear() {

    // clear out the bags
    foreach ($this->bags as $bag) {
      $bag
        ->clear();
    }

    // clear out the session
    $this->data = array();

    // reconnect the bags to the session
    $this
      ->loadSession();
  }

  /**
   * {@inheritdoc}
   */
  public function registerBag(SessionBagInterface $bag) {
    $this->bags[$bag
      ->getName()] = $bag;
  }

  /**
   * {@inheritdoc}
   */
  public function getBag($name) {
    if (!isset($this->bags[$name])) {
      throw new \InvalidArgumentException(sprintf('The SessionBagInterface %s is not registered.', $name));
    }
    if (!$this->started) {
      $this
        ->start();
    }
    return $this->bags[$name];
  }

  /**
   * {@inheritdoc}
   */
  public function isStarted() {
    return $this->started;
  }

  /**
   * Sets the MetadataBag.
   *
   * @param MetadataBag $bag
   */
  public function setMetadataBag(MetadataBag $bag = null) {
    if (null === $bag) {
      $bag = new MetadataBag();
    }
    $this->metadataBag = $bag;
  }

  /**
   * Gets the MetadataBag.
   *
   * @return MetadataBag
   */
  public function getMetadataBag() {
    return $this->metadataBag;
  }

  /**
   * Generates a session ID.
   *
   * This doesn't need to be particularly cryptographically secure since this is just
   * a mock.
   *
   * @return string
   */
  protected function generateId() {
    return hash('sha256', uniqid('ss_mock_', true));
  }
  protected function loadSession() {
    $bags = array_merge($this->bags, array(
      $this->metadataBag,
    ));
    foreach ($bags as $bag) {
      $key = $bag
        ->getStorageKey();
      $this->data[$key] = isset($this->data[$key]) ? $this->data[$key] : array();
      $bag
        ->initialize($this->data[$key]);
    }
    $this->started = true;
    $this->closed = false;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
MockArraySessionStorage::$bags protected property
MockArraySessionStorage::$closed protected property
MockArraySessionStorage::$data protected property
MockArraySessionStorage::$id protected property
MockArraySessionStorage::$metadataBag protected property
MockArraySessionStorage::$name protected property
MockArraySessionStorage::$started protected property
MockArraySessionStorage::clear public function Clear all session data in memory. Overrides SessionStorageInterface::clear
MockArraySessionStorage::generateId protected function Generates a session ID.
MockArraySessionStorage::getBag public function Gets a SessionBagInterface by name. Overrides SessionStorageInterface::getBag
MockArraySessionStorage::getId public function Returns the session ID. Overrides SessionStorageInterface::getId
MockArraySessionStorage::getMetadataBag public function Gets the MetadataBag. Overrides SessionStorageInterface::getMetadataBag
MockArraySessionStorage::getName public function Returns the session name. Overrides SessionStorageInterface::getName
MockArraySessionStorage::isStarted public function Checks if the session is started. Overrides SessionStorageInterface::isStarted
MockArraySessionStorage::loadSession protected function
MockArraySessionStorage::regenerate public function Regenerates id that represents this storage. Overrides SessionStorageInterface::regenerate 1
MockArraySessionStorage::registerBag public function Registers a SessionBagInterface for use. Overrides SessionStorageInterface::registerBag
MockArraySessionStorage::save public function Force the session to be saved and closed. Overrides SessionStorageInterface::save 1
MockArraySessionStorage::setId public function Sets the session ID. Overrides SessionStorageInterface::setId
MockArraySessionStorage::setMetadataBag public function Sets the MetadataBag.
MockArraySessionStorage::setName public function Sets the session name. Overrides SessionStorageInterface::setName
MockArraySessionStorage::setSessionData public function Sets the session data.
MockArraySessionStorage::start public function Starts the session. Overrides SessionStorageInterface::start 1
MockArraySessionStorage::__construct public function Constructor. 1