private function getUserId(array $inputData)
{
if (f\not($inputData, 'user_id')) {
throw new UserNotFoundException();
}
return f\get($inputData, 'user_id');
}
/**
* @return TokenGrantTypeProcessorInterface
*/
private function findProcessor($grantType)
{
if (f\contains($this->processors, $grantType)) {
return f\get($this->processors, $grantType);
}
throw new UnsupportedGrantTypeOAuthErrorException();
}
private function findUser($username)
{
$isUser = function ($user) use($username) {
return f\get($user, 'username') === $username;
};
return f\find($isUser, $this->users);
}
public function process(Client $client, array $inputData)
{
$userId = f\get($client, 'id');
$scopes = $this->scopesObtainer->getScopes($inputData);
$context = new Context($client, $userId, $scopes);
return $this->tokenCreator->create($context);
}
private function getToken($data)
{
$token = f\get($data, 'token');
if (f\not(is_string($token))) {
throw new \InvalidArgumentException('Token must be a strong.');
}
return $token;
}
public function testFind()
{
$accessToken = $this->createAccessToken();
$key = f\get($accessToken, 'token');
$value = $accessToken->getParams();
$this->cache->shouldReceive('fetch')->once()->with($key)->andReturn($value);
$this->assertEquals($accessToken, $this->repository->find(f\get($accessToken, 'token')));
}
public function testFindAllShouldReturnAllClients()
{
$newClient1 = new Client('foo');
$newClient2 = new Client('bar');
$addedClient1 = $this->repository->add($newClient1);
$addedClient2 = $this->repository->add($newClient2);
$this->assertEquals([f\get($addedClient1, 'id') => $addedClient1, f\get($addedClient2, 'id') => $addedClient2], $this->repository->findAll());
}
public function testCreate()
{
$context = $this->createContextMock();
$accessToken = $this->createAccessToken();
$this->accessTokenCreator->shouldReceive('create')->once()->with($context)->andReturn($accessToken);
$response = $this->tokenCreator->create($context);
$this->assertSame(['access_token' => f\get($accessToken, 'token'), 'token_type' => f\get($accessToken, 'type'), 'expires_in' => f\get($accessToken, 'lifetime'), 'scope' => f\get($accessToken, 'scope')], $response);
}
/**
* f\get_in($coll, $in)
*
* Returns a element of a collection in a nested structure in.
* An InvalidArgumentException is thrown if the in does not exist.
*
* f\get_in(array('a' => array('a1' => 'foo'), array('a', 'a1');
* => 'foo'
*/
function get_in($coll, $in)
{
$arrayIn = f\_coll_in($coll, $in);
if ($arrayIn === false) {
return $default;
}
return f\get($arrayIn, f\last($in));
}
/**
* @expectedException \Akamon\OAuth2\Server\Domain\Exception\OAuthError\InvalidRefreshTokenOAuthErrorException
*/
public function testItThrowsAnExceptionIfThereAccessTokenDoesNotExist()
{
$refreshToken = $this->createRefreshToken();
$this->refreshTokenRepository->shouldReceive('find')->with(f\get($refreshToken, 'token'))->once()->andReturn($refreshToken)->ordered();
$this->accessTokenRepository->shouldReceive('find')->with(f\get($refreshToken, 'accessTokenToken'))->andReturnNull()->ordered();
$this->refreshTokenRepository->shouldReceive('remove')->with($refreshToken)->once()->ordered();
$this->processor->process($this->createClient(), ['refresh_token' => f\get($refreshToken, 'token')]);
}
public function resolve(Context $context)
{
if (f\not($context->getScopes()->isEmpty())) {
return $context;
}
$defaultScopes = ScopeCollection::createFromString(f\get($context->getClient(), 'defaultScope'));
return new Context($context->getClient(), $context->getUserId(), $defaultScopes);
}
private function getUserCredentialsFromInputData($inputData)
{
if ($this->hasNoUserCredentialsInInputData($inputData)) {
throw new UserCredentialsNotFoundException();
}
$username = f\get($inputData, 'username');
$password = f\get($inputData, 'password');
return new UserCredentials($username, $password);
}
public function testRemoveShouldRemoveAToken()
{
$token1 = $this->createAccessToken();
$token2 = $this->createAccessToken();
$this->repository->add($token1);
$this->repository->add($token2);
$this->repository->remove($token2);
$this->assertEquals($token1, $this->repository->find(f\get($token1->getParams(), 'token')));
$this->assertNull($this->repository->find(f\get($token2->getParams(), 'token')));
}
public function testRemoveShouldRemoveAToken($value = '')
{
$token1 = $this->createRefreshToken();
$token2 = $this->createRefreshToken();
$this->repository->add($token1);
$this->repository->add($token2);
$this->repository->remove($token2);
$this->assertEquals($token1, $this->repository->find(f\get($token1, 'token')));
$this->assertNull($this->repository->find(f\get($token2, 'token')));
}
public function testOk()
{
$refreshToken = $this->createRefreshToken();
$params = ['access_token' => 'foo', 'token_type' => 'bar', 'lifetime' => 20];
$context = $this->createContextMock();
$this->delegate->shouldReceive('create')->with($context)->once()->andReturn($params)->ordered();
$this->refreshTokenCreator->shouldReceive('create')->with($params['access_token'])->once()->andReturn($refreshToken);
$expected = array_merge($params, ['refresh_token' => f\get($refreshToken, 'token')]);
$this->assertSame($expected, $this->creator->create($context));
}
private function findUser($username)
{
$getUser = function ($user) use($username) {
return f\get($user, 'username') === $username;
};
$user = f\find($getUser, $this->users);
if (f\not($user)) {
throw new UserNotFoundException();
}
return $user;
}
public function testCreateShouldCreateAnAccessToken()
{
$token = sha1('foo');
$this->tokenGenerator->shouldReceive('generate')->once()->andReturn($token);
$client = new Client(['id' => 'ups', 'name' => 'pablodip']);
$userId = 'bar';
$scopes = new ScopeCollection([new Scope('foo'), new Scope('bar')]);
$context = new Context($client, $userId, $scopes);
$accessToken = $this->creator->create($context);
$this->assertInstanceOf('Akamon\\OAuth2\\Server\\Domain\\Model\\AccessToken\\AccessToken', $accessToken);
$this->assertSame(array('token' => $token, 'type' => 'bearer', 'clientId' => f\get($client, 'id'), 'userId' => $userId, 'createdAt' => time(), 'lifetime' => $this->lifetime, 'scope' => 'foo bar'), $accessToken->getParams());
}
public function testShouldCheckUniqueness()
{
$accessTokenToken = 'ups';
$refreshToken1 = $this->createRefreshToken();
$refreshToken2 = $this->createRefreshToken();
$this->delegate->shouldReceive('create')->with($accessTokenToken)->once()->andReturn($refreshToken1)->globally()->ordered();
$this->repository->shouldReceive('find')->with(f\get($refreshToken1, 'token'))->once()->andReturn($refreshToken1)->globally()->ordered();
$this->delegate->shouldReceive('create')->with($accessTokenToken)->once()->andReturn($refreshToken2)->globally()->ordered();
$this->repository->shouldReceive('find')->with(f\get($refreshToken2, 'token'))->once()->andReturnNull()->globally()->ordered();
$this->repository->shouldReceive('add')->once()->with($refreshToken2)->globally()->ordered();
$this->assertSame($refreshToken2, $this->creator->create($accessTokenToken));
}
public function testCreateShouldCheckUniqueness()
{
$context = $this->createContextMock();
$accessToken1 = $this->createAccessToken();
$accessToken2 = $this->createAccessToken();
$this->creator->shouldReceive('create')->with($context)->once()->andReturn($accessToken1)->globally()->ordered();
$this->repository->shouldReceive('find')->with(f\get($accessToken1, 'token'))->once()->andReturn($accessToken1)->globally()->ordered();
$this->creator->shouldReceive('create')->with($context)->once()->andReturn($accessToken2)->globally()->ordered();
$this->repository->shouldReceive('find')->with(f\get($accessToken2, 'token'))->once()->andReturnNull()->globally()->ordered();
$this->repository->shouldReceive('add')->with($accessToken2)->once();
$this->assertSame($accessToken2, $this->persistentCreator->create($context));
}
public function testOk()
{
$client = $this->createClient();
$userId = f\get($client, 'id');
$scope = 'foo';
$scopes = new ScopeCollection([new Scope($scope)]);
$context = new Context($client, $userId, $scopes);
$inputData = ['scope' => $scope];
$returnData = new \stdClass();
$this->scopesObtainer->shouldReceive('getScopes')->with($inputData)->once()->andReturn($scopes);
$this->tokenCreator->shouldReceive('create')->with(\Mockery::mustBe($context))->once()->andReturn($returnData);
$this->assertSame($returnData, $this->processor->process($client, $inputData));
}
function _coll_depth($array, $depth)
{
$first = f\first($depth);
if (f\contains($array, $first)) {
$arrayIn = f\to_array(f\get($array, $first));
$inRest = f\rest($depth);
if (count($inRest)) {
return f\_coll_depth($arrayIn, $inRest);
}
return $arrayIn;
}
return false;
}
/**
* f\normalize_coll($coll, $normalizers)
*
* Returns a new collection normalizing the elements indicating in normalizers.
* It accepts param rules as normalizers.
* It's similar to map_indexed.
*
* f\normalize_coll(array('a' => 1.0), array('a' => 'intval'));
* => array('a' => 1)
*
* // elements without normalizers are returned without modification
* f\normalize_coll(array('a' => 1.0, 'b' => 2.0), array('a' => 'intval'));
* => array('a' => 1, 'b' => 2.0)
*
* // with param rules
* f\normalize_coll(array('a' => 1.0), array('a' => f\required('normalizer' => 'intval')));
* => array('a' => 1)
*/
function normalize_coll($collection, $normalizers)
{
$result = f\to_array($collection);
foreach ($normalizers as $name => $normalizer) {
if ($normalizer instanceof param_rule) {
$normalizer = $normalizer->getNormalizer();
if (f\not($normalizer)) {
continue;
}
}
$result[$name] = call_user_func($normalizer, f\get($collection, $name));
}
return $result;
}
/**
* f\fill($coll, $paramRules)
*
* Returns a new collection filled with param rules.
* If a param is optional and it does not exist and there is a default value, it's filled.
* If a param exists and there is no param rule for that param, it's not filled.
*
* // filling with empty coll
* f\fill(array(), array('a' => f\optional(array('d' => 1)));
* => array('a' => 1)
*
* // filling with existing coll
* f\fill(array('a' => 1), array('a' => f\required(), 'b' => f\optional(array('d' => 2)));
* => array('a' => 1, 'b' => 2)
*
* // without param rule
* f\fill(array('a' => 1, 'b' => 2), array('a' => f\required()));
* => array()
*/
function fill($coll, $paramRules)
{
$fill = function ($rule, $key) use($coll) {
if (f\not($rule instanceof param_rule)) {
throw new \InvalidArgumentException('Fill rules must be created with felpado\\required and felpado\\optional.');
}
if ($rule instanceof optional) {
$value = f\get_or($coll, $key, $rule->getDefaultValue());
} else {
$value = f\get($coll, $key);
}
return $value;
};
return f\map_indexed($fill, $paramRules);
}
private function getContext(Client $client, array $inputData)
{
if (f\not(f\contains($inputData, 'refresh_token'))) {
throw new RefreshTokenNotFoundOAuthErrorException();
}
$refreshToken = $this->refreshTokenRepository->find(f\get($inputData, 'refresh_token'));
if (f\not($refreshToken)) {
throw new InvalidRefreshTokenOAuthErrorException();
}
if ($refreshToken->isExpired()) {
throw new ExpiredRefreshTokenOAuthErrorException();
}
$accessToken = $this->accessTokenRepository->find(f\get($refreshToken, 'accessTokenToken'));
if (f\not($accessToken)) {
$this->refreshTokenRepository->remove($refreshToken);
throw new InvalidRefreshTokenOAuthErrorException();
}
$this->refreshTokenRepository->remove($refreshToken);
$this->accessTokenRepository->remove($accessToken);
return new Context($client, f\get($accessToken, 'userId'), ScopeCollection::createFromString(f\get($accessToken, 'scope')));
}
/**
* f\validate_coll($coll, $paramRules)
*
* Returns the validation errors when validating coll with param rules.
*
* // validating existence
* f\validate_coll(array(), array('a' => f\required(), 'b' => f\optional()));
* => array('a' => 'required')
*
* // multiple errors
* f\validate_coll(array(), array('a' => f\required(), 'b' => f\required()));
* => array('a' => 'required', 'b' => 'required')
*
* // validator fn
* f\validate_coll(array('a' => 1.0), array('a' => f\required('v' => 'is_int')));
* => array('a' => 'invalid')
*
* // without errors
* f\validate_coll(array('a' => 1), array('a' => f\required('v' => 'is_int')));
* => array()
*/
function validate_coll($coll, $paramRules)
{
$validate = function ($paramRule, $key) use($coll) {
if (f\not($paramRule instanceof param_rule)) {
throw new \InvalidArgumentException('Param rules must be created with felpado\\required and felpado\\optional.');
}
if (f\contains($coll, $key)) {
if ($paramRule->getValidator()) {
$value = f\get($coll, $key);
if (f\not(is_null($value) && $paramRule instanceof optional)) {
$isValid = f\validate($value, $paramRule->getValidator());
if (f\not($isValid)) {
return 'invalid';
}
}
}
} elseif ($paramRule instanceof required) {
return 'required';
}
return null;
};
return f\filter_indexed('felpado\\identity', f\map($validate, $paramRules));
}
public function testFind()
{
$refreshToken = $this->createRefreshToken();
$this->cache->shouldReceive('fetch')->once()->with(f\get($refreshToken, 'token'))->andReturn($refreshToken->getParams());
$this->assertEquals($refreshToken, $this->repository->find(f\get($refreshToken, 'token')));
}
/**
* @return array An array of parameters.
*/
public function create(Context $context)
{
$params = $this->delegate->create($context);
$refreshToken = $this->refreshTokenCreator->create(f\get($params, 'access_token'));
return f\assoc($params, 'refresh_token', f\get($refreshToken, 'token'));
}
public function hasAllowedScope($scope)
{
return array_search($scope, f\get($this, 'allowedScopes')) !== false;
}
private function filterParamsFromDomain($params)
{
return f\assoc($params, 'oauth2Id', f\get($params, 'id'));
}
public function create(Context $context)
{
$accessToken = $this->accessTokenCreator->create($context);
return ['access_token' => f\get($accessToken, 'token'), 'token_type' => f\get($accessToken, 'type'), 'expires_in' => f\get($accessToken, 'lifetime'), 'scope' => f\get($accessToken, 'scope')];
}
