public function fetchConfigurationValue(string $configPath)
{
if (null === $this->parameterBag) {
throw new \LogicException('Parameter bag should be injected with setter method first');
}
return $this->parameterBag->get($configPath);
}
/**
* Gets a config.
*
* @param string $name The config name
*
* @return mixed The config value
*/
public function get($key, $default = null)
{
try {
return $this->parameterBag->get($key);
} catch (ParameterNotFoundException $e) {
if (null !== $default) {
return $default;
}
}
throw $e;
}
/**
* @param string $name
* @param mixed $default
*
* @return mixed
*/
public function getParameter($name, $default = null)
{
if ($name === 'db_table_prefix' && defined('MAUTIC_TABLE_PREFIX')) {
//use the constant in case in the installer
return MAUTIC_TABLE_PREFIX;
}
if ($this->parameterBag->has('mautic.' . $name)) {
return $this->parameterBag->get('mautic.' . $name);
}
// Last ditch effort in case we're getting non-mautic params
if ($this->parameterBag->has($name)) {
return $this->parameterBag->get($name);
}
return $default;
}
/**
* Loads a parameter given the format "namespace.key"
*
* @param string $configurationIdentifier Configuration identifier
* @param string $defaultValue Default value
*
* @return null|string|boolean Configuration parameter value
*
* @throws ConfigurationParameterNotFoundException Configuration parameter not found
* @throws Exception Configuration cannot be resolved
*/
public function get($configurationIdentifier, $defaultValue = null)
{
/**
* Checks if the value is defined in the configuration elements
*/
if (!array_key_exists($configurationIdentifier, $this->configurationElements)) {
if (!is_null($defaultValue)) {
return $defaultValue;
}
throw new ConfigurationParameterNotFoundException();
}
$valueIsCached = $this->cache->contains($configurationIdentifier);
/**
* The value is cached, so we can securely return its value.
* We must unserialize the value if needed
*/
if (false !== $valueIsCached) {
return $this->cache->fetch($configurationIdentifier);
}
list($configurationNamespace, $configurationKey) = $this->splitConfigurationKey($configurationIdentifier);
$configurationLoaded = $this->loadConfiguration($configurationNamespace, $configurationKey);
if (!$configurationLoaded instanceof ConfigurationInterface) {
$configurationElement = $this->configurationElements[$configurationIdentifier];
$configurationValue = isset($configurationElement['reference']) ? $this->parameterBag->get($configurationElement['reference']) : $configurationElement['default_value'];
if (empty($configurationValue) && !$configurationElement['can_be_empty']) {
$message = $configurationElement['empty_message'] ?: 'The configuration element "' . $configurationIdentifier . '" cannot be resolved';
throw new Exception($message);
}
$configurationLoaded = $this->createConfigurationInstance($configurationIdentifier, $configurationNamespace, $configurationKey, $configurationValue);
$this->flushConfiguration($configurationLoaded);
}
$configurationValueUnserialized = $this->flushConfigurationToCache($configurationLoaded, $configurationIdentifier);
return $configurationValueUnserialized;
}
function it_gets_credentials(Request $request, ParameterBagInterface $headersBag)
{
$headersBag->has('Authorization')->shouldBeCalled()->willReturn(true);
$headersBag->get('Authorization')->shouldBeCalled()->willReturn('Bearer bearer-token');
$request->headers = $headersBag;
$this->getCredentials($request)->shouldReturn('bearer-token');
}
function it_joins_slack(ContainerInterface $container, Request $request, ParameterBagInterface $bag)
{
$container->getParameter('slack_org')->shouldBeCalled()->willReturn('slack-org');
$container->getParameter('slack_apiKey')->shouldBeCalled()->willReturn('slack-api-key');
$bag->get('email');
$request->query = $bag;
$request->get('email')->shouldBeCalled()->willReturn('*****@*****.**');
$this->joinSlackAction($request)->shouldReturnAnInstanceOf('Symfony\\Component\\HttpFoundation\\Response');
}
function it_gets_credentials(Request $request, ParameterBagInterface $parameterBag, ParameterBagInterface $attributesBag, SessionInterface $session)
{
$parameterBag->get('_email')->shouldBeCalled()->willReturn('*****@*****.**');
$parameterBag->get('_password')->shouldBeCalled()->willReturn('111111');
$attributesBag->get('_route')->shouldBeCalled()->willReturn('bengor_user_user_security_login_check');
$request->request = $parameterBag;
$request->attributes = $attributesBag;
$request->getSession()->shouldBeCalled()->willReturn($session);
$session->set(Security::LAST_USERNAME, '*****@*****.**')->shouldBeCalled();
$this->getCredentials($request)->shouldReturnAnInstanceOf(LogInUserCommand::class);
}
function it_enable_action(ContainerInterface $container, Request $request, ParameterBagInterface $bag, UserCommandBus $commandBus, Session $session, FlashBagInterface $flashBag, Router $router, Translator $translator)
{
$request->query = $bag;
$bag->get('confirmation-token')->shouldBeCalled()->willReturn('confirmation-token');
$container->get('bengor_user.user.command_bus')->shouldBeCalled()->willReturn($commandBus);
$commandBus->handle(Argument::type(EnableUserCommand::class))->shouldBeCalled();
$container->get('translator')->shouldBeCalled()->willReturn($translator);
$container->has('session')->shouldBeCalled()->willReturn(true);
$container->get('session')->shouldBeCalled()->willReturn($session);
$session->getFlashBag()->shouldBeCalled()->willReturn($flashBag);
$container->get('router')->shouldBeCalled()->willReturn($router);
$router->generate('bengor_user_user_homepage', [], UrlGeneratorInterface::ABSOLUTE_PATH)->shouldBeCalled()->willReturn('/');
$this->enableAction($request, 'user', 'bengor_user_user_homepage');
}
function it_listens_interactive_login(InteractiveLoginEvent $interactiveLoginEvent, TokenInterface $token, UserInterface $user, Request $request, SessionInterface $session, ParameterBagInterface $parameterBag, ClientManagerInterface $clientManager, ClientInterface $client, OAuth2 $oauthServer, Response $response)
{
$interactiveLoginEvent->getAuthenticationToken()->shouldBeCalled()->willReturn($token);
$token->getUser()->shouldBeCalled()->willReturn($user);
$interactiveLoginEvent->getRequest()->shouldBeCalled()->willReturn($request);
$parameterBag->get('_username')->shouldBeCalled()->willReturn('*****@*****.**');
$parameterBag->get('_password')->shouldBeCalled()->willReturn('123456');
$request->request = $parameterBag;
$request->getSession()->shouldBeCalled()->willReturn($session);
$session->set('_email', '*****@*****.**')->shouldBeCalled();
$session->set('_password', '123456')->shouldBeCalled();
$clientManager->findClientBy(['secret' => 'client-secret'])->shouldBeCalled()->willReturn($client);
$client->getId()->shouldBeCalled()->willReturn('the-id');
$client->getRandomId()->shouldBeCalled()->willReturn('random-id');
$session->get('_email')->shouldBeCalled()->willReturn('*****@*****.**');
$session->get('_password')->shouldBeCalled()->willReturn('123456');
$oauthServer->grantAccessToken(Argument::type('Symfony\\Component\\HttpFoundation\\Request'))->shouldBeCalled()->willReturn($response);
$response->getContent()->shouldBeCalled()->willReturn('the response content');
$session->remove('_email')->shouldBeCalled()->willReturn('*****@*****.**');
$session->remove('_password')->shouldBeCalled()->willReturn('123456');
$session->replace(['access_token' => null, 'refresh_token' => null])->shouldBeCalled();
$this->onInteractiveLogin($interactiveLoginEvent);
}
function it_login_action(Request $request, ContainerInterface $container, AuthorizationCheckerInterface $authorizationChecker, AuthenticationUtils $helper, ParameterBagInterface $parameterBag, TwigEngine $templating, Response $response)
{
$container->get('security.authorization_checker')->shouldBeCalled()->willReturn($authorizationChecker);
$authorizationChecker->isGranted('IS_AUTHENTICATED_FULLY')->shouldBeCalled()->willReturn(false);
$container->get('security.authentication_utils')->shouldBeCalled()->willReturn($helper);
$helper->getLastUsername()->shouldBeCalled()->willReturn('*****@*****.**');
$helper->getLastAuthenticationError()->shouldBeCalled()->willReturn('error');
$parameterBag->get('_route')->shouldBeCalled()->willReturn('login');
$request->attributes = $parameterBag;
$container->has('templating')->shouldBeCalled()->willReturn(true);
$container->get('templating')->shouldBeCalled()->willReturn($templating);
$templating->renderResponse('@BenGorUser/security/login.html.twig', ['last_email' => '*****@*****.**', 'error' => 'error', 'login_check' => 'login_check'], null)->shouldBeCalled()->willReturn($response);
$this->loginAction($request, 'admin')->shouldReturn($response);
}
/**
* Gets a parameter.
*
* @param string $name The parameter name
*
* @return mixed The parameter value
*
* @throws InvalidArgumentException if the parameter is not defined
*/
public function getParameter($name)
{
return $this->parameterBag->get($name);
}
function it_registers_successfully(Request $request, ParameterBagInterface $bag, ContainerInterface $container, UserRepository $repository, UserInterface $user, HandlerInterface $handler, FormInterface $form, EventDispatcherInterface $eventDispatcher, FormEvent $event, UserManager $userManager, TokenStorageInterface $context, TokenInterface $token, RouterInterface $router)
{
$request->query = $bag;
$bag->get('token')->shouldBeCalled()->willReturn(null);
$request->getMethod()->shouldBeCalled()->willReturn('POST');
$bag->get('email')->shouldBeCalled()->willReturn('*****@*****.**');
$container->get('kreta_user.repository.user')->shouldBeCalled()->willReturn($repository);
$repository->findOneBy(['email' => '*****@*****.**'], false)->shouldBeCalled()->willReturn($user);
$container->get('kreta_user.form_handler.registration')->shouldBeCalled()->willReturn($handler);
$handler->createForm($user)->shouldBeCalled()->willReturn($form);
$form->setData($user)->shouldBeCalled()->willReturn($form);
$form->handleRequest($request)->shouldBeCalled()->willReturn($form);
$form->isValid()->shouldBeCalled()->willReturn(true);
$user->setEnabled(true)->shouldBeCalled()->willReturn($user);
$user->setConfirmationToken(null)->shouldBeCalled()->willReturn($user);
$container->get('event_dispatcher')->shouldBeCalled()->willReturn($eventDispatcher);
$eventDispatcher->dispatch(FOSUserEvents::REGISTRATION_SUCCESS, Argument::type('FOS\\UserBundle\\Event\\FormEvent'))->shouldBeCalled()->willReturn($event);
$container->get('fos_user.user_manager')->shouldBeCalled()->willReturn($userManager);
$userManager->updateUser($user)->shouldBeCalled();
$eventDispatcher->dispatch(FOSUserEvents::REGISTRATION_COMPLETED, Argument::type('FOS\\UserBundle\\Event\\FilterUserResponseEvent'))->shouldBeCalled()->willReturn($event);
$container->has('security.token_storage')->shouldBeCalled()->willReturn(true);
$container->get('security.token_storage')->shouldBeCalled()->willReturn($context);
$context->getToken()->shouldBeCalled()->willReturn($token);
$token->getUser()->shouldBeCalled()->willReturn($user);
$eventDispatcher->dispatch(AuthorizationEvent::NAME, Argument::type('Kreta\\Bundle\\UserBundle\\Event\\AuthorizationEvent'))->shouldBeCalled()->willReturn($event);
$container->get('router')->shouldBeCalled()->willReturn($router);
$router->generate('kreta_web_homepage', [], false)->shouldBeCalled()->willReturn('http://kreta.io/');
$this->registerAction($request);
}
/**
* Gets a parameter.
*
* @param string $name The parameter name
* @param string $default The default value
*
* @return mixed The parameter value
*/
public function getParameter($name = null, $default = null)
{
return $this->parameterBag->has($name) ? $this->parameterBag->get($name) : $default;
}
/**
* Given an entity parameter definition, returns associated repository.
*
* This method is only useful when your entities namespaces are defined as
* a parameter, very useful when you want to provide a way of overriding
* entities easily
*
* @param string $entityParameter Entity Parameter
*
* @return ObjectRepository Repository
*/
public function getRepositoryByEntityParameter($entityParameter)
{
$entityNamespace = $this->parameterBag->get($entityParameter);
return $this->getRepositoryByEntityNamespace($entityNamespace);
}
function it_does_not_render_because_invitation_token_does_not_exist(ParameterBagInterface $bag, Request $request, ContainerInterface $container, UserOfInvitationTokenHandler $handler)
{
$bag->get('invitation-token')->willReturn('invitation-token');
$request->query = $bag;
$invitationTokenQuery = new UserOfInvitationTokenQuery('invitation-token');
$container->get('bengor_user.user.by_invitation_token_query')->shouldBeCalled()->willReturn($handler);
$handler->__invoke($invitationTokenQuery)->shouldBeCalled()->willThrow(UserDoesNotExistException::class);
$this->shouldThrow(NotFoundHttpException::class)->duringByInvitationAction($request, 'user', 'main', SignUpByInvitationType::class);
}
function it_does_not_change_password_because_token_does_not_exist(ParameterBagInterface $bag, Request $request, ContainerInterface $container, UserOfRememberPasswordTokenHandler $handler)
{
$request->query = $bag;
$bag->get('remember-password-token')->shouldBeCalled()->willReturn('remember-password-token');
$rememberPasswordTokenQuery = new UserOfRememberPasswordTokenQuery('remember-password-token');
$container->get('bengor_user.user.by_remember_password_token_query')->shouldBeCalled()->willReturn($handler);
$handler->__invoke($rememberPasswordTokenQuery)->shouldBeCalled()->willThrow(UserDoesNotExistException::class);
$this->shouldThrow(NotFoundHttpException::class)->duringByRequestRememberPasswordAction($request, 'user', 'bengor_user_user_homepage');
}
