/**
* 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 the resolvable is not resolved when the authorized value is different
*/
public function testResolveUnregisteredWithAuthorizedValue()
{
$action1 = $this->getResolvable();
$action1->method("resolved")->willReturn(false);
$action1->expects($this->never())->method("resolve");
$never = $this->getResolvable();
$never->method("resolved")->willReturn(false);
$never->expects($this->never())->method("resolve");
ResolvableAuthorizationRegistry::register('never', $never);
$this->manager->rules[] = new Rule($never, "*");
$this->manager->rules[] = new Rule($action1, "action1");
$this->manager->resolveUnregistered("action2");
$this->assertCount(2, $this->manager->rules);
}
/**
* 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);
}
