silverstripe / silverstripe-hybridsessions

src/Store/CookieStore.php

Unused Use Statements -1 removed lines

@@ -4,7 +4,6 @@
 
 use SilverStripe\Control\Cookie;
 use SilverStripe\HybridSessions\Crypto\CryptoHandler;
-use SilverStripe\Core\Config\Config;
 use SilverStripe\Core\Injector\Injector;
 
 /**

Indentation +180 added lines, -180 removed lines

@@ -22,184 +22,184 @@
 class CookieStore extends BaseStore
 {
 
-    /**
-     * Maximum length of a cookie value in characters
-     *
-     * @var int
-     * @config
-     */
-    private static $max_length = 1024;
-
-    /**
-     * Encryption service
-     *
-     * @var HybridSessionStore_Crypto
-     */
-    protected $crypto;
-
-    /**
-     * Name of cookie
-     *
-     * @var string
-     */
-    protected $cookie;
-
-    /**
-     * Known unmodified value of this cookie. If the cookie backend has been read into the application,
-     * then the backend is unable to verify the modification state of this value internally within the
-     * system, so this will be left null unless written back.
-     *
-     * If the content exceeds max_length then the backend can also not maintain this cookie, also
-     * setting this variable to null.
-     *
-     * @var string
-     */
-    protected $currentCookieData;
-
-    public function open($save_path, $name)
-    {
-        $this->cookie = $name . '_2';
-
-        // Read the incoming value, then clear the cookie - we might not be able
-        // to do so later if write() is called after headers are sent
-        // This is intended to force a failover to the database store if the
-        // modified session cannot be emitted.
-        $this->currentCookieData = Cookie::get($this->cookie);
-
-        if ($this->currentCookieData) {
-            Cookie::set($this->cookie, '');
-        }
-    }
-
-    public function close()
-    {
-    }
-
-    /**
-     * Get the cryptography store for the specified session
-     *
-     * @param string $session_id
-     * @return HybridSessionStore_Crypto
-     */
-    protected function getCrypto($session_id)
-    {
-        $key = $this->getKey();
-
-        if (!$key) {
-            return null;
-        }
-
-        if (!$this->crypto || $this->crypto->getSalt() != $session_id) {
-            $this->crypto = Injector::inst()->create(CryptoHandler::class, $key, $session_id);
-        }
-
-        return $this->crypto;
-    }
-
-    public function read($session_id)
-    {
-        // Check ability to safely decrypt content
-        if (!$this->currentCookieData
-            || !($crypto = $this->getCrypto($session_id))
-        ) {
-            return;
-        }
-
-        // Decrypt and invalidate old data
-        $cookieData = $crypto->decrypt($this->currentCookieData);
-        $this->currentCookieData = null;
-
-        // Verify expiration
-        if ($cookieData) {
-            $expiry = (int)substr($cookieData, 0, 10);
-            $data = substr($cookieData, 10);
-
-            if ($expiry > $this->getNow()) {
-                return $data;
-            }
-        }
-    }
-
-    /**
-     * Determine if the session could be verifably written to cookie storage
-     *
-     * @return bool
-     */
-    protected function canWrite()
-    {
-        return !headers_sent();
-    }
-
-    public function write($session_id, $session_data)
-    {
-        $canWrite = $this->canWrite();
-        $isExceedingCookieLimit = (strlen($session_data) > static::config()->get('max_length'));
-        $crypto = $this->getCrypto($session_id);
-
-        // Check ability to safely encrypt and write content
-        if (!$canWrite || $isExceedingCookieLimit || !$crypto) {
-            if ($canWrite && $isExceedingCookieLimit) {
-                $params = session_get_cookie_params();
-                // Clear stored cookie value and cookie when length exceeds the set limit
-                $this->currentCookieData = null;
-                Cookie::set(
-                    $this->cookie,
-                    '',
-                    0,
-                    $params['path'],
-                    $params['domain'],
-                    $params['secure'],
-                    $params['httponly']
-                );
-            }
-
-            return false;
-        }
-
-        // Prepare content for write
-        $params = session_get_cookie_params();
-        // Total max lifetime, stored internally
-        $lifetime = $this->getLifetime();
-        $expiry = $this->getNow() + $lifetime;
-
-        // Restore the known good cookie value
-        $this->currentCookieData = $this->crypto->encrypt(
-            sprintf('%010u', $expiry) . $session_data
-        );
-
-        // Respect auto-expire on browser close for the session cookie (in case the cookie lifetime is zero)
-        $cookieLifetime = min((int)$params['lifetime'], $lifetime);
-
-        Cookie::set(
-            $this->cookie,
-            $this->currentCookieData,
-            $cookieLifetime / 86400,
-            $params['path'],
-            $params['domain'],
-            $params['secure'],
-            $params['httponly']
-        );
-
-        return true;
-    }
-
-    public function destroy($session_id)
-    {
-        $this->currentCookieData = null;
-
-        $params = session_get_cookie_params();
-
-        Cookie::force_expiry(
-            $this->cookie,
-            $params['path'],
-            $params['domain'],
-            $params['secure'],
-            $params['httponly']
-        );
-    }
-
-    public function gc($maxlifetime)
-    {
-        // NOP
-    }
+	/**
+	 * Maximum length of a cookie value in characters
+	 *
+	 * @var int
+	 * @config
+	 */
+	private static $max_length = 1024;
+
+	/**
+	 * Encryption service
+	 *
+	 * @var HybridSessionStore_Crypto
+	 */
+	protected $crypto;
+
+	/**
+	 * Name of cookie
+	 *
+	 * @var string
+	 */
+	protected $cookie;
+
+	/**
+	 * Known unmodified value of this cookie. If the cookie backend has been read into the application,
+	 * then the backend is unable to verify the modification state of this value internally within the
+	 * system, so this will be left null unless written back.
+	 *
+	 * If the content exceeds max_length then the backend can also not maintain this cookie, also
+	 * setting this variable to null.
+	 *
+	 * @var string
+	 */
+	protected $currentCookieData;
+
+	public function open($save_path, $name)
+	{
+		$this->cookie = $name . '_2';
+
+		// Read the incoming value, then clear the cookie - we might not be able
+		// to do so later if write() is called after headers are sent
+		// This is intended to force a failover to the database store if the
+		// modified session cannot be emitted.
+		$this->currentCookieData = Cookie::get($this->cookie);
+
+		if ($this->currentCookieData) {
+			Cookie::set($this->cookie, '');
+		}
+	}
+
+	public function close()
+	{
+	}
+
+	/**
+	 * Get the cryptography store for the specified session
+	 *
+	 * @param string $session_id
+	 * @return HybridSessionStore_Crypto
+	 */
+	protected function getCrypto($session_id)
+	{
+		$key = $this->getKey();
+
+		if (!$key) {
+			return null;
+		}
+
+		if (!$this->crypto || $this->crypto->getSalt() != $session_id) {
+			$this->crypto = Injector::inst()->create(CryptoHandler::class, $key, $session_id);
+		}
+
+		return $this->crypto;
+	}
+
+	public function read($session_id)
+	{
+		// Check ability to safely decrypt content
+		if (!$this->currentCookieData
+			|| !($crypto = $this->getCrypto($session_id))
+		) {
+			return;
+		}
+
+		// Decrypt and invalidate old data
+		$cookieData = $crypto->decrypt($this->currentCookieData);
+		$this->currentCookieData = null;
+
+		// Verify expiration
+		if ($cookieData) {
+			$expiry = (int)substr($cookieData, 0, 10);
+			$data = substr($cookieData, 10);
+
+			if ($expiry > $this->getNow()) {
+				return $data;
+			}
+		}
+	}
+
+	/**
+	 * Determine if the session could be verifably written to cookie storage
+	 *
+	 * @return bool
+	 */
+	protected function canWrite()
+	{
+		return !headers_sent();
+	}
+
+	public function write($session_id, $session_data)
+	{
+		$canWrite = $this->canWrite();
+		$isExceedingCookieLimit = (strlen($session_data) > static::config()->get('max_length'));
+		$crypto = $this->getCrypto($session_id);
+
+		// Check ability to safely encrypt and write content
+		if (!$canWrite || $isExceedingCookieLimit || !$crypto) {
+			if ($canWrite && $isExceedingCookieLimit) {
+				$params = session_get_cookie_params();
+				// Clear stored cookie value and cookie when length exceeds the set limit
+				$this->currentCookieData = null;
+				Cookie::set(
+					$this->cookie,
+					'',
+					0,
+					$params['path'],
+					$params['domain'],
+					$params['secure'],
+					$params['httponly']
+				);
+			}
+
+			return false;
+		}
+
+		// Prepare content for write
+		$params = session_get_cookie_params();
+		// Total max lifetime, stored internally
+		$lifetime = $this->getLifetime();
+		$expiry = $this->getNow() + $lifetime;
+
+		// Restore the known good cookie value
+		$this->currentCookieData = $this->crypto->encrypt(
+			sprintf('%010u', $expiry) . $session_data
+		);
+
+		// Respect auto-expire on browser close for the session cookie (in case the cookie lifetime is zero)
+		$cookieLifetime = min((int)$params['lifetime'], $lifetime);
+
+		Cookie::set(
+			$this->cookie,
+			$this->currentCookieData,
+			$cookieLifetime / 86400,
+			$params['path'],
+			$params['domain'],
+			$params['secure'],
+			$params['httponly']
+		);
+
+		return true;
+	}
+
+	public function destroy($session_id)
+	{
+		$this->currentCookieData = null;
+
+		$params = session_get_cookie_params();
+
+		Cookie::force_expiry(
+			$this->cookie,
+			$params['path'],
+			$params['domain'],
+			$params['secure'],
+			$params['httponly']
+		);
+	}
+
+	public function gc($maxlifetime)
+	{
+		// NOP
+	}
 }

src/Store/BaseStore.php

Indentation +52 added lines, -52 removed lines

@@ -8,56 +8,56 @@
 
 abstract class BaseStore implements SessionHandlerInterface
 {
-    use Configurable;
-
-    /**
-     * Session secret key
-     *
-     * @var string
-     */
-    protected $key = null;
-
-    /**
-     * Assign a new session secret key
-     *
-     * @param string $key
-     */
-    public function setKey($key)
-    {
-        $this->key = $key;
-    }
-
-    /**
-     * Get the session secret key
-     *
-     * @return string
-     */
-    protected function getKey()
-    {
-        return $this->key;
-    }
-
-    /**
-     * Get lifetime in number of seconds
-     *
-     * @return int
-     */
-    protected function getLifetime()
-    {
-        $params = session_get_cookie_params();
-        $cookieLifetime = (int)$params['lifetime'];
-        $gcLifetime = (int)ini_get('session.gc_maxlifetime');
-
-        return $cookieLifetime ? min($cookieLifetime, $gcLifetime) : $gcLifetime;
-    }
-
-    /**
-     * Gets the current unix timestamp
-     *
-     * @return int
-     */
-    protected function getNow()
-    {
-        return (int) DBDatetime::now()->getTimestamp();
-    }
+	use Configurable;
+
+	/**
+	 * Session secret key
+	 *
+	 * @var string
+	 */
+	protected $key = null;
+
+	/**
+	 * Assign a new session secret key
+	 *
+	 * @param string $key
+	 */
+	public function setKey($key)
+	{
+		$this->key = $key;
+	}
+
+	/**
+	 * Get the session secret key
+	 *
+	 * @return string
+	 */
+	protected function getKey()
+	{
+		return $this->key;
+	}
+
+	/**
+	 * Get lifetime in number of seconds
+	 *
+	 * @return int
+	 */
+	protected function getLifetime()
+	{
+		$params = session_get_cookie_params();
+		$cookieLifetime = (int)$params['lifetime'];
+		$gcLifetime = (int)ini_get('session.gc_maxlifetime');
+
+		return $cookieLifetime ? min($cookieLifetime, $gcLifetime) : $gcLifetime;
+	}
+
+	/**
+	 * Gets the current unix timestamp
+	 *
+	 * @return int
+	 */
+	protected function getNow()
+	{
+		return (int) DBDatetime::now()->getTimestamp();
+	}
 }

src/Model/HybridSessionDataObject.php

Indentation +12 added lines, -12 removed lines

@@ -6,18 +6,18 @@
 
 class HybridSessionDataObject extends DataObject
 {
-    private static $db = [
-        'SessionID' => 'Varchar(64)',
-        'Expiry' => 'Int',
-        'Data' => 'Text'
-    ];
+	private static $db = [
+		'SessionID' => 'Varchar(64)',
+		'Expiry' => 'Int',
+		'Data' => 'Text'
+	];
 
-    private static $indexes = [
-        'SessionID' => [
-            'type' => 'unique'
-        ],
-        'Expiry' => true
-    ];
+	private static $indexes = [
+		'SessionID' => [
+			'type' => 'unique'
+		],
+		'Expiry' => true
+	];
 
-    private static $table_name = 'HybridSessionDataObject';
+	private static $table_name = 'HybridSessionDataObject';
 }

src/Crypto/CryptoHandler.php

Indentation +20 added lines, -20 removed lines

@@ -5,27 +5,27 @@
 interface CryptoHandler
 {
 
-    /**
-     * @param string $data
-     *
-     * @return string
-     */
-    public function encrypt($data);
+	/**
+	 * @param string $data
+	 *
+	 * @return string
+	 */
+	public function encrypt($data);
 
-    /**
-     * @param string $data
-     *
-     * @return string
-     */
-    public function decrypt($data);
+	/**
+	 * @param string $data
+	 *
+	 * @return string
+	 */
+	public function decrypt($data);
 
-    /**
-     * @return string
-     */
-    public function getKey();
+	/**
+	 * @return string
+	 */
+	public function getKey();
 
-    /**
-     * @return string
-     */
-    public function getSalt();
+	/**
+	 * @return string
+	 */
+	public function getSalt();
 }

src/Control/HybridSessionMiddleware.php

Indentation +18 added lines, -18 removed lines

@@ -8,25 +8,25 @@
 
 class HybridSessionMiddleware implements HTTPMiddleware
 {
-    public function process(HTTPRequest $request, callable $delegate)
-    {
-        try {
-            // Start session and execute
-            $request->getSession()->init($request);
+	public function process(HTTPRequest $request, callable $delegate)
+	{
+		try {
+			// Start session and execute
+			$request->getSession()->init($request);
 
-            // Generate output
-            $response = $delegate($request);
-        } finally {
-            // Save session data, even if there was an exception
-            // Note that save() will start/resume the session if required.
-            $request->getSession()->save($request);
+			// Generate output
+			$response = $delegate($request);
+		} finally {
+			// Save session data, even if there was an exception
+			// Note that save() will start/resume the session if required.
+			$request->getSession()->save($request);
 
-            if (HybridSession::is_enabled()) {
-                // Close the session
-                session_write_close();
-            }
-        }
+			if (HybridSession::is_enabled()) {
+				// Close the session
+				session_write_close();
+			}
+		}
 
-        return $response;
-    }
+		return $response;
+	}
 }

tests/ConfigurationTest.php

Indentation +8 added lines, -8 removed lines

@@ -9,12 +9,12 @@
 
 class ConfigurationTest extends SapphireTest
 {
-    public function testHybridSessionsSessionMiddlewareReplacesCore()
-    {
-        $this->assertInstanceOf(
-            HybridSessionMiddleware::class,
-            Injector::inst()->get(SessionMiddleware::class),
-            'HybridSession\'s middleware should replace the default SessionMiddleware'
-        );
-    }
+	public function testHybridSessionsSessionMiddlewareReplacesCore()
+	{
+		$this->assertInstanceOf(
+			HybridSessionMiddleware::class,
+			Injector::inst()->get(SessionMiddleware::class),
+			'HybridSession\'s middleware should replace the default SessionMiddleware'
+		);
+	}
 }

tests/AbstractTest.php

Indentation +100 added lines, -100 removed lines

@@ -10,104 +10,104 @@
 
 abstract class AbstractTest extends SapphireTest
 {
-    protected $usesDatabase = true;
-
-    protected function setUp()
-    {
-        parent::setUp();
-
-        TestCookieStore::$override_headers_sent = false;
-
-        Injector::inst()->registerService(
-            new TestCookieStore(),
-            CookieStore::class
-        );
-
-        DBDatetime::set_mock_now('2010-03-15 12:00:00');
-    }
-
-    protected function tearDown()
-    {
-        DBDatetime::clear_mock_now();
-
-        parent::tearDown();
-    }
-
-    abstract protected function getStore();
-
-    /**
-     * Test how this store handles large volumes of data (>1000 characters)
-     */
-    public function testStoreLargeData()
-    {
-        $session = uniqid();
-        $store = $this->getStore();
-
-        // Test new session is blank
-        $result = $store->read($session);
-        $this->assertEmpty($result);
-
-        // Save data against session
-        $data1 = array(
-            'Large' => str_repeat('A', 600),
-            'Content' => str_repeat('B', 600)
-        );
-        $store->write($session, serialize($data1));
-        $result = $store->read($session);
-        $this->assertEquals($data1, unserialize($result));
-    }
-
-    /**
-     * Test storage of data
-     */
-    public function testStoreData()
-    {
-        $session = uniqid();
-        $store = $this->getStore();
-
-        // Test new session is blank
-        $result = $store->read($session);
-        $this->assertEmpty($result);
-
-        // Save data against session
-        $data1 = array(
-            'Color' => 'red',
-            'Animal' => 'elephant'
-        );
-        $store->write($session, serialize($data1));
-        $result = $store->read($session);
-        $this->assertEquals($data1, unserialize($result));
-
-        // Save larger data
-        $data2 = array(
-            'Color' => 'blue',
-            'Animal' => str_repeat('bat', 100)
-        );
-        $store->write($session, serialize($data2));
-        $result = $store->read($session);
-        $this->assertEquals($data2, unserialize($result));
-    }
-
-    /**
-     * Test expiry of data
-     */
-    public function testExpiry()
-    {
-        $session1 = uniqid();
-        $store = $this->getStore();
-
-        // Store data now
-        $data1 = array(
-            'Food' => 'Pizza'
-        );
-        $store->write($session1, serialize($data1));
-        $result1 = $store->read($session1);
-        $this->assertEquals($data1, unserialize($result1));
-
-        // Go to the future and test that the expiry is accurate
-        DBDatetime::set_mock_now('2040-03-16 12:00:00');
-        $result2 = $store->read($session1);
-
-        $this->assertEmpty($result2);
-    }
+	protected $usesDatabase = true;
+
+	protected function setUp()
+	{
+		parent::setUp();
+
+		TestCookieStore::$override_headers_sent = false;
+
+		Injector::inst()->registerService(
+			new TestCookieStore(),
+			CookieStore::class
+		);
+
+		DBDatetime::set_mock_now('2010-03-15 12:00:00');
+	}
+
+	protected function tearDown()
+	{
+		DBDatetime::clear_mock_now();
+
+		parent::tearDown();
+	}
+
+	abstract protected function getStore();
+
+	/**
+	 * Test how this store handles large volumes of data (>1000 characters)
+	 */
+	public function testStoreLargeData()
+	{
+		$session = uniqid();
+		$store = $this->getStore();
+
+		// Test new session is blank
+		$result = $store->read($session);
+		$this->assertEmpty($result);
+
+		// Save data against session
+		$data1 = array(
+			'Large' => str_repeat('A', 600),
+			'Content' => str_repeat('B', 600)
+		);
+		$store->write($session, serialize($data1));
+		$result = $store->read($session);
+		$this->assertEquals($data1, unserialize($result));
+	}
+
+	/**
+	 * Test storage of data
+	 */
+	public function testStoreData()
+	{
+		$session = uniqid();
+		$store = $this->getStore();
+
+		// Test new session is blank
+		$result = $store->read($session);
+		$this->assertEmpty($result);
+
+		// Save data against session
+		$data1 = array(
+			'Color' => 'red',
+			'Animal' => 'elephant'
+		);
+		$store->write($session, serialize($data1));
+		$result = $store->read($session);
+		$this->assertEquals($data1, unserialize($result));
+
+		// Save larger data
+		$data2 = array(
+			'Color' => 'blue',
+			'Animal' => str_repeat('bat', 100)
+		);
+		$store->write($session, serialize($data2));
+		$result = $store->read($session);
+		$this->assertEquals($data2, unserialize($result));
+	}
+
+	/**
+	 * Test expiry of data
+	 */
+	public function testExpiry()
+	{
+		$session1 = uniqid();
+		$store = $this->getStore();
+
+		// Store data now
+		$data1 = array(
+			'Food' => 'Pizza'
+		);
+		$store->write($session1, serialize($data1));
+		$result1 = $store->read($session1);
+		$this->assertEquals($data1, unserialize($result1));
+
+		// Go to the future and test that the expiry is accurate
+		DBDatetime::set_mock_now('2040-03-16 12:00:00');
+		$result2 = $store->read($session1);
+
+		$this->assertEmpty($result2);
+	}
 }

tests/DatabaseStoreTest.php

Indentation +13 added lines, -13 removed lines

@@ -9,20 +9,20 @@
 
 class DatabaseStoreTest extends AbstractTest
 {
-    protected function setUp()
-    {
-        parent::setUp();
+	protected function setUp()
+	{
+		parent::setUp();
 
-        if (!DB::get_conn() instanceof MySQLDatabase) {
-            $this->markTestSkipped('Only MySQL databases are supported');
-        }
-    }
+		if (!DB::get_conn() instanceof MySQLDatabase) {
+			$this->markTestSkipped('Only MySQL databases are supported');
+		}
+	}
 
-    protected function getStore()
-    {
-        $store = Injector::inst()->get(DatabaseStore::class);
-        $store->setKey(uniqid());
+	protected function getStore()
+	{
+		$store = Injector::inst()->get(DatabaseStore::class);
+		$store->setKey(uniqid());
 
-        return $store;
-    }
+		return $store;
+	}
 }

tests/HybridSessionTest.php

Indentation +79 added lines, -79 removed lines

@@ -9,83 +9,83 @@
 
 class HybridSessionTest extends SapphireTest
 {
-    /**
-     * @var BaseStore
-     */
-    protected $handler;
-
-    /**
-     * @var HybridSession
-     */
-    protected $instance;
-
-    protected function setUp()
-    {
-        parent::setUp();
-
-        $this->handler = $this->createMock(TestCookieStore::class);
-
-        $this->instance = new HybridSession();
-    }
-
-    public function testSetHandlersAlsoSetsKeyToEachHandler()
-    {
-        $this->instance->setKey('foobar');
-        $this->handler->expects($this->once())->method('setKey')->with('foobar');
-        $this->instance->setHandlers([$this->handler]);
-    }
-
-    public function testOpenDelegatesToAllHandlers()
-    {
-        $this->handler->expects($this->once())->method('open')->with('foo', 'bar');
-        $this->instance->setHandlers([$this->handler]);
-        $this->assertTrue($this->instance->open('foo', 'bar'), 'Method returns true after delegation');
-    }
-
-    public function testCloseDelegatesToAllHandlers()
-    {
-        $this->handler->expects($this->once())->method('close');
-        $this->instance->setHandlers([$this->handler]);
-        $this->assertTrue($this->instance->close(), 'Method returns true after delegation');
-    }
-
-    public function testReadReturnsEmptyStringWithNoHandlers()
-    {
-        $this->handler->expects($this->once())->method('read')->with('foosession')->willReturn(false);
-        $this->instance->setHandlers([$this->handler]);
-        $this->assertSame('', $this->instance->read('foosession'));
-    }
-
-    public function testReadReturnsHandlerDelegateResult()
-    {
-        $this->handler->expects($this->once())->method('read')->with('foo.session')->willReturn('success!');
-        $this->instance->setHandlers([$this->handler]);
-        $this->assertSame('success!', $this->instance->read('foo.session'));
-    }
-
-    public function testWriteDelegatesToHandlerAndReturnsTrue()
-    {
-        $this->handler->expects($this->once())->method('write')->with('foo', 'bar')->willReturn(true);
-        $this->instance->setHandlers([$this->handler]);
-        $this->assertTrue($this->instance->write('foo', 'bar'));
-    }
-
-    public function testWriteReturnsFalseWithNoHandlers()
-    {
-        $this->assertFalse($this->instance->write('no', 'handlers'));
-    }
-
-    public function testDestroyDelegatesToHandler()
-    {
-        $this->handler->expects($this->once())->method('destroy')->with('sessid1234');
-        $this->instance->setHandlers([$this->handler]);
-        $this->assertTrue($this->instance->destroy('sessid1234'), 'Method returns true after delegation');
-    }
-
-    public function testGcDelegatesToHandlers()
-    {
-        $this->handler->expects($this->once())->method('gc')->with(12345);
-        $this->instance->setHandlers([$this->handler]);
-        $this->instance->gc(12345);
-    }
+	/**
+	 * @var BaseStore
+	 */
+	protected $handler;
+
+	/**
+	 * @var HybridSession
+	 */
+	protected $instance;
+
+	protected function setUp()
+	{
+		parent::setUp();
+
+		$this->handler = $this->createMock(TestCookieStore::class);
+
+		$this->instance = new HybridSession();
+	}
+
+	public function testSetHandlersAlsoSetsKeyToEachHandler()
+	{
+		$this->instance->setKey('foobar');
+		$this->handler->expects($this->once())->method('setKey')->with('foobar');
+		$this->instance->setHandlers([$this->handler]);
+	}
+
+	public function testOpenDelegatesToAllHandlers()
+	{
+		$this->handler->expects($this->once())->method('open')->with('foo', 'bar');
+		$this->instance->setHandlers([$this->handler]);
+		$this->assertTrue($this->instance->open('foo', 'bar'), 'Method returns true after delegation');
+	}
+
+	public function testCloseDelegatesToAllHandlers()
+	{
+		$this->handler->expects($this->once())->method('close');
+		$this->instance->setHandlers([$this->handler]);
+		$this->assertTrue($this->instance->close(), 'Method returns true after delegation');
+	}
+
+	public function testReadReturnsEmptyStringWithNoHandlers()
+	{
+		$this->handler->expects($this->once())->method('read')->with('foosession')->willReturn(false);
+		$this->instance->setHandlers([$this->handler]);
+		$this->assertSame('', $this->instance->read('foosession'));
+	}
+
+	public function testReadReturnsHandlerDelegateResult()
+	{
+		$this->handler->expects($this->once())->method('read')->with('foo.session')->willReturn('success!');
+		$this->instance->setHandlers([$this->handler]);
+		$this->assertSame('success!', $this->instance->read('foo.session'));
+	}
+
+	public function testWriteDelegatesToHandlerAndReturnsTrue()
+	{
+		$this->handler->expects($this->once())->method('write')->with('foo', 'bar')->willReturn(true);
+		$this->instance->setHandlers([$this->handler]);
+		$this->assertTrue($this->instance->write('foo', 'bar'));
+	}
+
+	public function testWriteReturnsFalseWithNoHandlers()
+	{
+		$this->assertFalse($this->instance->write('no', 'handlers'));
+	}
+
+	public function testDestroyDelegatesToHandler()
+	{
+		$this->handler->expects($this->once())->method('destroy')->with('sessid1234');
+		$this->instance->setHandlers([$this->handler]);
+		$this->assertTrue($this->instance->destroy('sessid1234'), 'Method returns true after delegation');
+	}
+
+	public function testGcDelegatesToHandlers()
+	{
+		$this->handler->expects($this->once())->method('gc')->with(12345);
+		$this->instance->setHandlers([$this->handler]);
+		$this->instance->gc(12345);
+	}
 }