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));
 }