Author: Fabien Potencier (fabien@symfony.com)
 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);
 }
 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_sets_the_request_attribute_from_the_current_time(GetResponseEvent $event, ParameterBagInterface $attributesParameterBag)
 {
     $request = new Request([], [], [], [], [], []);
     $request->attributes = $attributesParameterBag->getWrappedObject();
     $event->getRequest()->willReturn($request);
     $attributesParameterBag->set('_tolerance_request_time', Argument::type('float'))->shouldBeCalled();
     $this->onRequest($event);
 }
 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('info@php.eus');
     $this->joinSlackAction($request)->shouldReturnAnInstanceOf('Symfony\\Component\\HttpFoundation\\Response');
 }
Beispiel #5
0
 /**
  * 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;
 }
 function it_gets_credentials(Request $request, ParameterBagInterface $parameterBag, ParameterBagInterface $attributesBag, SessionInterface $session)
 {
     $parameterBag->get('_email')->shouldBeCalled()->willReturn('test@test.com');
     $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, 'test@test.com')->shouldBeCalled();
     $this->getCredentials($request)->shouldReturnAnInstanceOf(LogInUserCommand::class);
 }
 public function setUp()
 {
     $this->asset = $this->getMock('Assetic\\Asset\\AssetInterface');
     $parameters = array('foo' => 'foo value', 'bar' => 'bar value', 'foo.bar' => 'foo dot bar value', 'null' => null, 'quotes' => '"aren\'t quotes wonderful"', 'array' => array('test' => 'something'));
     $this->parameterBag = $this->getMock('Symfony\\Component\\DependencyInjection\\ParameterBag\\ParameterBagInterface');
     $this->parameterBag->expects($this->any())->method('get')->will($this->returnCallback(function ($key) use($parameters) {
         return $parameters[$key];
     }));
     $this->parameterBag->expects($this->any())->method('has')->will($this->returnCallback(function ($key) use($parameters) {
         return array_key_exists($key, $parameters);
     }));
 }
 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_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('last@email.com');
     $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' => 'last@email.com', 'error' => 'error', 'login_check' => 'login_check'], null)->shouldBeCalled()->willReturn($response);
     $this->loginAction($request, 'admin')->shouldReturn($response);
 }
Beispiel #10
0
 /**
  * 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;
 }
 /**
  * @return array
  */
 private function getIgnoredServicePatterns()
 {
     try {
         return (array) $this->parameterBag->resolveValue("%autowiring.ignored_services%");
     } catch (ParameterNotFoundException $exception) {
         return [];
     }
 }
Beispiel #12
0
 /**
  * Extracts filter type parameters from dom-node.
  *
  * @param \DOMXPath $xpath
  * @param \DOMNode $propertyNode
  *
  * @return array
  */
 protected function getFilterTypeParameters(\DOMXPath $xpath, \DOMNode $propertyNode)
 {
     $parameters = [];
     foreach ($xpath->query('x:filter-type-parameters/x:parameter', $propertyNode) as $parameterNode) {
         $key = XmlUtil::getValueFromXPath('@key', $xpath, $parameterNode);
         $parameters[$key] = $this->parameterBag->resolveValue(trim($parameterNode->nodeValue));
     }
     return $parameters;
 }
 /**
  * {@inheritdoc}
  */
 public function load($file, $type = null)
 {
     $path = $this->locator->locate($file);
     if (!class_exists('Symfony\\Component\\Yaml\\Parser')) {
         throw new \RuntimeException('Unable to load YAML config files as the Symfony Yaml Component is not installed.');
     }
     if (!stream_is_local($path)) {
         throw new \InvalidArgumentException(sprintf('This is not a local file "%s".', $path));
     }
     if (!file_exists($path)) {
         throw new \InvalidArgumentException(sprintf('File "%s" not found.', $path));
     }
     if (null === $this->yamlParser) {
         $this->yamlParser = new YamlParser();
     }
     try {
         $parsedConfig = $this->yamlParser->parse(file_get_contents($path));
     } catch (ParseException $e) {
         throw new \InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML.', $path), 0, $e);
     }
     if ($this->parameterBag) {
         $parsedConfig = $this->parameterBag->resolveValue($parsedConfig);
     }
     $collection = new RouteCollection();
     $collection->addResource(new FileResource($path));
     // empty file
     if (null === $parsedConfig) {
         return $collection;
     }
     // not an array
     if (!is_array($parsedConfig)) {
         throw new \InvalidArgumentException(sprintf('The file "%s" must contain a YAML array.', $path));
     }
     foreach ($parsedConfig as $name => $config) {
         $this->validate($config, $name, $path);
         if (isset($config['resource'])) {
             $this->parseImport($collection, $config, $path, $file);
         } else {
             $this->parseRoute($collection, $name, $config, $path);
         }
     }
     return $collection;
 }
 /**
  * @param string $eventName
  * @param array $values 
  * @param string|null $tracker
  * @return string
  */
 public function tcEvent($eventName, $values = array(), $tracker = null)
 {
     if (is_null($tracker)) {
         $tracker = $this->defaultEvent;
     }
     $function = $this->events[$tracker]['function'];
     $event = new Track($tracker, $eventName, array_merge($this->datalayer->all(), $values));
     $this->dispatcher->dispatch('tc_event', $event);
     return sprintf("%s('%s', %s);", $function, $eventName, $this->serializeWithValues($values));
 }
Beispiel #15
0
 /**
  * {@inheritdoc}
  */
 public function load($resource, $type = null)
 {
     $path = $this->locator->locate($resource);
     $content = $this->loadFile($path);
     // empty file
     if (null === $content) {
         return;
     }
     // imports
     $this->parseImports($content, $path);
     $content = $this->parameterBag->resolveValue($content);
     foreach ($content as $namespace => $values) {
         if (in_array($namespace, ['imports'])) {
             continue;
         }
         if (isset($this->container[$namespace]) && is_array($values)) {
             $values = $this->merge($this->container[$namespace], $values);
         }
         $this->container[$namespace] = $values;
     }
     return $content;
 }
 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('kreta@kreta.com');
     $parameterBag->get('_password')->shouldBeCalled()->willReturn('123456');
     $request->request = $parameterBag;
     $request->getSession()->shouldBeCalled()->willReturn($session);
     $session->set('_email', 'kreta@kreta.com')->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('kreta@kreta.com');
     $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('kreta@kreta.com');
     $session->remove('_password')->shouldBeCalled()->willReturn('123456');
     $session->replace(['access_token' => null, 'refresh_token' => null])->shouldBeCalled();
     $this->onInteractiveLogin($interactiveLoginEvent);
 }
 /**
  * Retrieve a value.
  *
  * @param string $path The path of the value.
  *
  * @return array|null
  */
 public function get($path)
 {
     // special case, root element.
     if ($path === static::PATH_SEPARATOR) {
         return $this->data;
     }
     $chunks = $this->splitPath($path);
     $scope = $this->data;
     if (empty($chunks)) {
         return null;
     }
     while (null !== ($sub = array_shift($chunks))) {
         if (isset($scope[$sub])) {
             $scope = $scope[$sub];
         } else {
             return null;
         }
     }
     return $this->parameterBag->resolveValue($scope);
 }
 /**
  * @inheritdoc
  */
 public function hash()
 {
     return serialize($this->parameterBag->all());
 }
 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('kreta@kreta.com');
     $container->get('kreta_user.repository.user')->shouldBeCalled()->willReturn($repository);
     $repository->findOneBy(['email' => 'kreta@kreta.com'], 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);
 }
 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');
 }
Beispiel #22
0
 /**
  * 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;
 }
Beispiel #23
0
 /**
  * @param string $value
  *
  * @return string
  */
 protected function resolveParameter($value)
 {
     return $this->parameterBag->resolveValue($value);
 }
 /**
  * @inheritdoc
  */
 public function __construct(ParameterBagInterface $parameterBag = null)
 {
     // This is not elegant, but it works.
     parent::__construct(new DrupalFrozenParameterBag($parameterBag->all()));
     $this->services['service_container'] = $this;
 }
 /**
  * {@inheritDoc}
  */
 public function collect(Request $request, Response $response, \Exception $exception = null)
 {
     $this->data['values'] = $this->datalayer->all();
 }
 /**
  * @param string $name
  *
  * @return bool
  */
 public function hasParameter($name)
 {
     return $this->parameterBag->has('mautic.' . $name);
 }
 protected function tearDown()
 {
     $this->params->clear();
 }
 /**
  * Sets a parameter.
  *
  * @param string $name  The parameter name
  * @param mixed  $value The parameter value
  */
 public function setParameter($name, $value)
 {
     $this->parameterBag->set($name, $value);
 }
Beispiel #29
0
 /**
  * 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);
 }