/**
* Resolve unregistered resolvable
*
* @param array $params
* @return null|void
*/
public function resolve($params = [])
{
parent::resolve($params);
if (!ResolvableAuthorizationRegistry::isRegistered($this->resolvable)) {
$this->manager->resolve($this->resolvable, $params);
}
}
/**
* tearDown method
*
* @return void
*/
public function tearDown()
{
unset($this->Authorization);
ResolvableAuthorizationInstance::reset();
ResolvableAuthorizationRegistry::reset();
parent::tearDown();
}
/**
* Resolve unregistered resolvables
*
* @param array $params
* @return null|void
*/
public function resolve($params = [])
{
foreach ($this->resolvables as $resolvable) {
if (!ResolvableAuthorizationRegistry::isRegistered($resolvable)) {
$this->manager->resolve($resolvable, $params);
}
}
}
/**
* Test that resolve not resolve registered
*/
public function testResolveRegisteredNotCalled()
{
$registered = $this->AuthorizationMock->AuthorizationMockUnresolved(true);
$registered->expects($this->never())->method("resolve");
ResolvableAuthorizationRegistry::register('test', $registered);
$authorization = new NotAuthorization();
$authorization->initialize($this->context);
$authorization->resolvable = $registered;
$authorization->resolve(['param']);
}
/**
* Test that resolve method resolve unregistered authorizations
*/
public function testResolve()
{
$registered = $this->AuthorizationMock->AuthorizationMockTrue();
$unregistered = $this->AuthorizationMock->AuthorizationMockTrue();
$registered->expects($this->never())->method("resolve");
$unregistered->expects($this->once())->method("resolve")->with(['param']);
ResolvableAuthorizationRegistry::register('test', $registered);
$authorization = new OrAuthorization();
$authorization->initialize($this->context);
$authorization->resolvables = [$registered, $unregistered];
$authorization->resolve(['param']);
}
/**
* Test that register function register an authorization
*/
public function testRegister()
{
$callback = function () {
};
$this->manager->registerResolvable('name', $this->manager->context($callback));
$this->assertTrue(ResolvableAuthorizationRegistry::isRegistered('name'));
$resolvable = ResolvableAuthorizationRegistry::get('name');
$this->assertInstanceOf("ResolveAuth\\Authorization\\Resolvable\\ContextAuthorization", $resolvable);
}
/**
* Creates instances from an array.
*
* Example :
* $array = [
* ['type', 'param'],
* ['Group', 'user'],
* 'ignoredAlreadyRegisteredResolvableAuthorization',
* $ignoredAlreadyRegisteredResolvableAuthorization
* ]
*
* @param $authorizationArray
* @return array
* @throws Exception
* @throws InvalidArgumentException
*/
public function createFromArray($authorizationArray)
{
$resolvables = [];
foreach ($authorizationArray as $resolvable) {
if (!is_array($resolvable)) {
$resolvables[] = ResolvableAuthorizationRegistry::get($resolvable);
continue;
}
$resolvables[] = ResolvableAuthorizationInstance::getInstance()->create($resolvable[0], $resolvable[1]);
}
return $resolvables;
}
/**
* Registers a registrable ResolvableAuthorizationInterface for later resolution
*
* @param string $key Name in registry
* @param ResolvableAuthorizationInterface $resolvable
* @return null
*/
public function registerResolvable($key, ResolvableAuthorizationInterface $resolvable)
{
if (!$resolvable->registrable()) {
throw new InvalidArgumentException($key . " isn't registrable");
}
ResolvableAuthorizationRegistry::register($key, $resolvable);
return $resolvable;
}
/**
* Create instances with already registered authorizations
*/
public function testCreateFromArrayWithRegistered()
{
$callback = function () {
return 1;
};
$contextAuthorization = new ContextAuthorization();
$contextAuthorization->initialize($this->context, $callback);
ResolvableAuthorizationRegistry::register('registered', $contextAuthorization);
$result = ResolvableAuthorizationInstance::getInstance()->createFromArray(['registered']);
$this->assertcount(1, $result);
$this->assertInstanceOf("ResolveAuth\\Authorization\\Resolvable\\ContextAuthorization", $contextAuthorization);
$this->assertSame($callback, $result[0]->params);
}
