/**
* @expectedException \AdammBalogh\KeyValueStore\Exception\InternalException
*/
public function testFlushWithNotReadableDatabase()
{
$flintstoneDb = Flintstone::load('okke', ['dir' => vfsStream::url('root')]);
$kvs = new KeyValueStore(new FileAdapter($flintstoneDb));
chmod(vfsStream::url('root/okke.dat'), 0500);
$kvs->flush();
}
/**
* @expectedException \Exception
*/
public function testFlushException()
{
$shmProxyStub = \Mockery::mock('\\AdammBalogh\\KeyValueStore\\Adapter\\SharedMemoryAdapter\\ShmProxy');
$shmProxyStub->shouldReceive('flush')->with($this->shmResource)->andReturn(false);
$kvs = new KeyValueStore(new SharedMemoryAdapter($this->shmResource, $shmProxyStub));
$kvs->flush();
}
/**
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemoryAdapter $memoryAdapter
*/
public function testFlush(KeyValueStore $kvs, MemoryAdapter $memoryAdapter)
{
$kvs->set('key', 5);
$this->assertTrue($kvs->has('key'));
$this->assertNull($kvs->flush());
$this->assertFalse($kvs->has('key'));
}
public function testSetError()
{
$memAdapterStub = \Mockery::mock('\\AdammBalogh\\KeyValueStore\\Adapter\\MemoryAdapter');
$memAdapterStub->shouldReceive('set')->andReturn(false);
$repAdapter = new ReplicatorAdapter($memAdapterStub, new MemoryAdapter());
$kvs = new KeyValueStore($repAdapter);
$this->assertFalse($kvs->set('key', 'value'));
}
/**
* @expectedException \AdammBalogh\KeyValueStore\Exception\InternalException
*/
public function testDeleteError()
{
$shmProxyStub = \Mockery::mock('\\AdammBalogh\\KeyValueStore\\Adapter\\SharedMemoryAdapter\\ShmProxy[remove]');
$shmProxyStub->shouldReceive('remove')->with($this->shmResource, 'key')->andReturn(false);
$kvs = new KeyValueStore(new SharedMemoryAdapter($this->shmResource, $shmProxyStub));
$kvs->set('key', 5);
$kvs->delete('key');
}
/**
* @expectedException \Exception
*/
public function testFlushError()
{
$memAdapterStub = \Mockery::mock('\\AdammBalogh\\KeyValueStore\\Adapter\\MemoryAdapter');
$memAdapterStub->shouldReceive('flush')->andThrow('\\Exception');
$repAdapter = new ReplicatorAdapter($memAdapterStub, new MemoryAdapter());
$kvs = new KeyValueStore($repAdapter);
$kvs->flush('key', 'value');
}
/**
* @expectedException \AdammBalogh\KeyValueStore\Exception\InternalException
*/
public function testHandleTtlError()
{
$shmProxyStub = \Mockery::mock('\\AdammBalogh\\KeyValueStore\\Adapter\\SharedMemoryAdapter\\ShmProxy[remove]');
$shmProxyStub->shouldReceive('remove')->andReturn(false);
$kvs = new KeyValueStore(new SharedMemoryAdapter($this->shmResource, $shmProxyStub));
$kvs->set('key', 'value');
$kvs->expire('key', 0);
sleep(1);
$kvs->get('key');
}
public static function getProvider($type, $params, $accessTokenParams = [])
{
$provider = new Pdffiller($params);
$tz = 'America/New_York';
$kvs = new KeyValueStore(new FileAdapter(Flintstone::load('usersDatabase', ['dir' => '/tmp'])));
$accessTokenKey = 'access_token';
if (!$kvs->has($accessTokenKey)) {
$accessToken = $provider->getAccessToken(self::$names[$type], $accessTokenParams);
$liveTimeInSec = Carbon::createFromTimestamp($accessToken->getExpires(), $tz)->diffInSeconds(Carbon::now($tz));
$kvs->set($accessTokenKey, $accessToken->getToken());
$kvs->expire($accessTokenKey, $liveTimeInSec);
$accessTokenString = $accessToken->getToken();
} else {
$accessTokenString = $kvs->get($accessTokenKey);
}
$provider->setAccessTokenHash($accessTokenString);
return $provider;
}
function __construct($token = null)
{
if ($token != null) {
$this->access_token = $token->access_token;
$this->refresh_token = $token->refresh_token;
$this->expired_in = $token->expired_in;
if ($this->getAccessTokenStatus() != 1) {
$keyValueStore = new KeyValueStore(new MemoryAdapter());
$keyValueStore->set('access_token', $this->access_token);
$keyValueStore->set('refresh_token', $this->refresh_token);
$keyValueStore->expire('access_token', 0);
$keyValueStore->expire('refresh_token', $this->expired_in + (5184000 - 3600) - time());
# 60 days
$oAuthClient = new OAuthClient($keyValueStore, $this->clientId, $this->clientSecret, $this->redirectUri);
$oAuthClient->authorize();
$keyValueStore = $oAuthClient->getKvs();
Token::where('access_token', $this->access_token)->where('refresh_token', $this->refresh_token)->update(array('access_token' => $keyValueStore->get('access_token'), 'refresh_token' => $keyValueStore->get('refresh_token'), 'expired_in' => time() + $keyValueStore->getTtl('access_token')));
$this->access_token = $keyValueStore->get('access_token');
$this->refresh_token = $keyValueStore->get('refresh_token');
$this->expired_in = time() + $keyValueStore->getTtl('access_token');
}
} else {
$keyValueStore = new KeyValueStore(new MemoryAdapter());
$oAuthClient = new OAuthClient($keyValueStore, $this->clientId, $this->clientSecret, $this->redirectUri);
try {
$oAuthClient->authorize();
$keyValueStore = $oAuthClient->getKvs();
$this->access_token = $keyValueStore->get('access_token');
$this->refresh_token = $keyValueStore->get('refresh_token');
$this->expired_in = time() + $keyValueStore->getTtl('access_token');
} catch (ExitException $e) {
# Location header has set (box's authorize page)
# Instead of an exit call it throws an ExitException
exit;
} catch (OAuthException $e) {
# e.g. Invalid user credentials
# e.g. The user denied access to your application
} catch (ClientException $e) {
# e.g. if $_GET['code'] is older than 30 sec
}
}
$this->state = (object) array('redirect_uri' => null, 'token' => null);
$this->state->token = (object) array('obtained' => null, 'data' => (object) array('access_token' => $this->access_token));
}
/**
* @param array $response
*/
protected function setPropertiesBasedOnSuccessResponse(array $response)
{
$this->accessToken = $response['access_token'];
$this->refreshToken = $response['refresh_token'];
if (array_key_exists('expires_in', $response)) {
$this->kvs->set('access_token', $this->accessToken);
$this->kvs->set('refresh_token', $this->refreshToken);
$this->kvs->expire('access_token', (int) $response['expires_in']);
$this->kvs->expire('refresh_token', 5184000);
# 60 days
}
}
/**
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemoryAdapter $memoryAdapter
*/
public function testSet(KeyValueStore $kvs, MemoryAdapter $memoryAdapter)
{
$kvs->set('key', [1, 2, 3]);
$this->assertEquals([1, 2, 3], $kvs->get('key'));
}
/**
* @expectedException \Exception
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param RedisAdapter $dummyRedisAdapter
* @param RedisClient $dummyPredis
*/
public function testFlushError(KeyValueStore $kvs, RedisAdapter $dummyRedisAdapter, RedisClient $dummyPredis)
{
$status = new Status('QUEUED');
$dummyPredis->shouldReceive('flushdb')->andReturn($status);
$kvs->flush();
}
/**
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param RedisAdapter $dummyRedisAdapter
* @param RedisClient $dummyPredis
*/
public function testPersist(KeyValueStore $kvs, RedisAdapter $dummyRedisAdapter, RedisClient $dummyPredis)
{
$dummyPredis->shouldReceive('persist')->with('key-e')->andReturn(1);
$dummyPredis->shouldReceive('persist')->with('key-ne')->andReturn(0);
$this->assertTrue($kvs->persist('key-e'));
$this->assertFalse($kvs->persist('key-ne'));
}
/**
* @expectedException \Exception
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemcacheAdapter $dummyMemchAdapter
* @param \Memcache $dummyMemch
*/
public function testPersistNonSerialized(KeyValueStore $kvs, MemcacheAdapter $dummyMemchAdapter, \Memcache $dummyMemch)
{
$dummyMemch->shouldReceive('get')->with('key-e')->andReturn('value-e');
$kvs->persist('key-e');
}
/**
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemcachedAdapter $dummyMemchdAdapter
* @param \Memcached $dummyMemchd
*/
public function testPersistNonSerialized(KeyValueStore $kvs, MemcachedAdapter $dummyMemchdAdapter, \Memcached $dummyMemchd)
{
$dummyMemchd->shouldReceive('get')->with('key-e')->andReturn('value-e');
$dummyMemchd->shouldReceive('getResultCode')->andReturn(\Memcached::RES_SUCCESS);
$this->assertFalse($kvs->persist('key-e'));
}
/**
* @expectedException \Exception
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemcacheAdapter $dummyMemchAdapter
* @param \Memcache $dummyMemch
*/
public function testGetValueError(KeyValueStore $kvs, MemcacheAdapter $dummyMemchAdapter, \Memcache $dummyMemch)
{
$dummyMemch->shouldReceive('get')->with('key-e')->andReturn(false);
$kvs->get('key-e');
}
/**
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemoryAdapter $memoryAdapter
*/
public function testPersistExpired(KeyValueStore $kvs, MemoryAdapter $memoryAdapter)
{
$kvs->set('key', 555);
$kvs->expire('key', 1);
sleep(2);
$this->assertFalse($kvs->persist('key'));
}
/**
* @expectedException \Exception
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemcachedAdapter $dummyMemchdAdapter
* @param \Memcached $dummyMemchd
*/
public function testGetValueError(KeyValueStore $kvs, MemcachedAdapter $dummyMemchdAdapter, \Memcached $dummyMemchd)
{
$dummyMemchd->shouldReceive('get')->with('key-e')->andReturn(false);
$dummyMemchd->shouldReceive('getResultCode')->andReturn(\Memcached::RES_SUCCESS);
$kvs->get('key-e');
}
/**
* @expectedException \Exception
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MemcacheAdapter $dummyMemchAdapter
* @param \Memcache $dummyMemch
*/
public function testFlushError(KeyValueStore $kvs, MemcacheAdapter $dummyMemchAdapter, \Memcache $dummyMemch)
{
$dummyMemch->shouldReceive('flush')->andReturn(false);
$kvs->flush();
}
/**
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param RedisAdapter $dummyRedisAdapter
* @param RedisClient $dummyPredis
*/
public function testSetError(KeyValueStore $kvs, RedisAdapter $dummyRedisAdapter, RedisClient $dummyPredis)
{
$status = new Status('QUEUED');
$dummyPredis->shouldReceive('set')->with('key-ne', serialize('value'))->andReturn($status);
$this->assertFalse($kvs->set('key-ne', 'value'));
}
/**
* @expectedException \AdammBalogh\KeyValueStore\Exception\InternalException
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MockInterface $dummyAdapter
*/
public function testPersistException(KeyValueStore $kvs, MockInterface $dummyAdapter)
{
$dummyAdapter->shouldReceive('persist')->andThrow('\\Exception');
$kvs->persist('key');
}
/**
* @expectedException \AdammBalogh\KeyValueStore\Exception\InternalException
*
* @dataProvider kvsProvider
*
* @param KeyValueStore $kvs
* @param MockInterface $dummyAdapter
*/
public function testSetException(KeyValueStore $kvs, MockInterface $dummyAdapter)
{
$dummyAdapter->shouldReceive('set')->andThrow('\\Exception');
$kvs->set('key', 'text');
}
