Get the domain name currently being used.
| public getDomainContext ( ) : string | ||
| return | string | |
/**
* {@inheritdoc}
*/
public function warmUp($cacheDir)
{
$domain = $this->ldap->getDomainContext();
foreach ($this->config->getDomainConfiguration() as $domainConfig) {
$this->ldap->switchDomain($domainConfig->getDomainName());
$schemaFactory = $this->ldap->getSchemaFactory();
$parser = $this->ldap->getSchemaParser();
$schema = empty($domainConfig->getSchemaName()) ? $domainConfig->getLdapType() : $domainConfig->getSchemaName();
$ldapObjects = $parser->parseAll($schema);
$this->cacheAllLdapSchemaObjects($schemaFactory, ...$ldapObjects);
}
$this->ldap->switchDomain($domain);
}
function it_should_switch_the_domain_if_the_token_has_the_ldap_domain_set()
{
// It first grabs a copy of the domain context, then checks against it, then checks it at the end...
$this->ldap->getDomainContext()->willReturn('foo.bar', 'foo.bar', 'example.local');
$this->token->hasAttribute('ldap_domain')->willReturn(true);
$this->token->getAttribute('ldap_domain')->willReturn('example.local');
$this->ldap->switchDomain('example.local')->shouldBeCalledTimes(1);
$this->ldap->switchDomain('foo.bar')->shouldBeCalledTimes(1);
$this->authenticate($this->token)->shouldReturnAnInstanceOf('\\Symfony\\Component\\Security\\Core\\Authentication\\Token\\UsernamePasswordToken');
}
/**
* {@inheritdoc}
*/
public function configureOptions(OptionsResolver $resolver)
{
$ldap = $this->ldap;
$resolver->setDefaults(['ldap_domain' => $this->ldap->getDomainContext(), 'ldap_attributes' => null, 'ldap_query_builder' => null, 'choice_name' => 'name', 'choice_value' => 'guid', 'choices' => [], 'choice_loader' => function (Options $options) use($ldap) {
if (!interface_exists('\\Symfony\\Component\\Form\\ChoiceList\\Loader\\ChoiceLoaderInterface')) {
return null;
}
return new LdapObjectChoiceLoader($ldap, $options['ldap_type'], $options['choice_name'], $options['choice_value'], $options['ldap_query_builder']);
}, 'choice_list' => function (Options $options) use($ldap) {
// Always prefer the ChoiceLoader if it exists. Fall back to the ObjectChoiceList...
if (interface_exists('\\Symfony\\Component\\Form\\ChoiceList\\Loader\\ChoiceLoaderInterface')) {
return null;
}
$legacyChoiceLoader = new LegacyLdapChoiceLoader($ldap, $options['ldap_type'], $options['choice_name'], $options['choice_value'], $options['ldap_query_builder']);
$preferred = isset($options['preferred_choices']) ? $options['preferred_choices'] : [];
return new LdapObjectChoiceList($legacyChoiceLoader->load(), $options['choice_name'], $preferred, null, $options['choice_value']);
}]);
$resolver->setRequired(['ldap_type']);
$this->setAllowedTypes($resolver);
}
function let(LdapManager $ldap, LdapConnectionInterface $connection, RouterInterface $router, EventDispatcherInterface $dispatcher)
{
$this->userChecker = new LdapUserChecker();
$this->request = new Request();
$this->request->setSession(new Session());
$router->generate('login')->willReturn('/login');
$connection->getConfig()->willReturn(new DomainConfiguration('foo.bar'));
$ldap->getConnection()->willReturn($connection);
$ldap->getDomainContext()->willReturn('foo.bar');
$this->beConstructedWith(true, $this->userChecker, $ldap, $router, $dispatcher);
}
/**
* @param \LdapTools\LdapManager $ldap
* @param \LdapTools\Connection\LdapConnectionInterface $connection
* @param \Symfony\Component\Routing\RouterInterface $router
* @param \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher
*/
function let($ldap, $connection, $router, $dispatcher)
{
$this->ldap = $ldap;
$this->router = $router;
$this->userChecker = new LdapUserChecker();
$this->connection = $connection;
$this->config = new DomainConfiguration('foo.bar');
$this->request = new Request();
$this->request->setSession(new Session());
$this->dispatcher = $dispatcher;
$this->router->generate('login')->willReturn('/login');
$this->connection->getConfig()->willReturn($this->config);
$this->ldap->getConnection()->willReturn($this->connection);
$this->ldap->getDomainContext()->willReturn('foo.bar');
$this->beConstructedWith(true, $this->userChecker, $ldap, $router, $dispatcher);
}
/**
* Based on an array of IDs for LDAP objects, set the property to either a LdapObject for LdapObjectCollection.
*
* @param \ReflectionProperty $property
* @param LdapObjectAnnotation $annotation
* @param $entity
*/
protected function setLdapObjectForProperty(\ReflectionProperty $property, LdapObjectAnnotation $annotation, $entity)
{
if (empty($property->getValue($entity))) {
return;
}
$domain = $this->ldap->getDomainContext();
$switchDomain = $annotation->domain ?: null;
if ($switchDomain) {
$this->ldap->switchDomain($annotation->domain);
}
$results = $this->queryLdapForObjects($property, $annotation, $entity);
$property->setValue($entity, $results);
if ($switchDomain) {
$this->ldap->switchDomain($domain);
}
}
public function let(LdapManager $ldap, LdapQueryBuilder $qb, LdapQuery $query, LdapObjectCollection $collection)
{
$ldap->getDomainContext()->willReturn('foo.bar');
$ldap->buildLdapQuery()->willReturn($qb);
$qb->select(Argument::any())->willReturn($qb);
$qb->from(Argument::any())->willReturn($qb);
$qb->getLdapQuery()->willReturn($query);
$query->getResult()->WillReturn($collection);
$collection->toArray()->willReturn([]);
$this->resolver = new OptionsResolver();
if (Kernel::VERSION >= 2.6) {
$this->resolver->setDefault('ldap_type', 'user');
} else {
$this->resolver->setDefaults(['ldap_type' => 'user']);
}
$this->beConstructedWith($ldap);
}
function let(Reader $reader, LdapManager $ldap, LifecycleEventArgs $eventArgs, ObjectManager $om, ClassMetadata $metadata, LdapObjectSchemaFactory $schemaFactory, LdapConnectionInterface $connection, LdapObjectSchema $schema, LdapQueryBuilder $qb, LdapQuery $query, $entity)
{
$rc = new \ReflectionClass('Doctrine\\Common\\Persistence\\Event\\LifecycleEventArgs');
if ($rc->hasMethod('getObjectManager')) {
$eventArgs->getObjectManager()->willReturn($om);
$eventArgs->getObject()->willReturn($entity);
} else {
$eventArgs->getEntityManager()->willReturn($om);
$eventArgs->getEntity()->willReturn($entity);
}
$om->getClassMetadata(Argument::any())->willReturn($metadata);
$this->config = new DomainConfiguration('foo.bar');
$connection->getConfig()->willReturn($this->config);
$ldap->getDomainContext()->willReturn('foo.bar');
$ldap->getSchemaFactory()->willReturn($schemaFactory);
$ldap->getConnection()->willReturn($connection);
$ldap->buildLdapQuery()->willReturn($qb);
$qb->getLdapQuery()->willReturn($query);
$this->beConstructedWith($reader, $ldap);
}
function let(UserProviderInterface $userProvider, LdapUserChecker $userChecker, LdapManager $ldap, TokenInterface $token, LdapUser $user, LdapConnectionInterface $connection, AuthenticationResponse $response, \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher)
{
$this->operation = (new AuthenticationOperation())->setUsername('foo')->setPassword('bar');
$token->getUsername()->willReturn('foo');
$token->getCredentials()->willReturn('bar');
$token->hasAttribute('ldap_domain')->willReturn(false);
$token->getAttributes()->willReturn([]);
$token->getUser()->willReturn($user);
$userProvider->loadUserByUsername('foo')->willReturn($user);
$connection->getConfig()->willReturn(new DomainConfiguration('foo.bar'));
$connection->execute($this->operation)->willReturn($response);
$response->isAuthenticated()->willReturn(true);
$ldap->getConnection()->willReturn($connection);
$ldap->getDomainContext()->willReturn('foo.bar');
$user->getUsername()->willReturn('foo');
$user->getRoles()->willReturn(['ROLE_USER']);
$user->isAccountNonLocked()->willReturn(true);
$user->isEnabled()->willReturn(true);
$user->isAccountNonExpired()->willReturn(true);
$user->isCredentialsNonExpired()->willReturn(true);
$this->beConstructedWith('restricted', true, $userProvider, new LdapUserChecker(), $ldap, $dispatcher);
}
/**
* If the passed domain is not the current context, then switch back to it.
*
* @param string $domain
*/
protected function switchDomainBackIfNeeded($domain)
{
if ($domain !== $this->ldap->getDomainContext()) {
$this->ldap->switchDomain($domain);
}
}