/** * Sets up this test case * */ protected function setUp() { $this->mockObjectManager = $this->createMock(ObjectManagerInterface::class); $this->mockObjectManager->expects($this->any())->method('isRegistered')->will($this->returnCallback(array($this, 'objectManagerIsRegisteredCallback'))); $this->parser = $this->getAccessibleMock(Parser::class, array('dummy')); $this->parser->_set('objectManager', $this->mockObjectManager); }
/** * Set the routes configuration for the Neos setup and configures the routing component * to skip initialisation, which would overwrite the specific settings again. * * @param ComponentContext $componentContext * @return void */ public function handle(ComponentContext $componentContext) { $configurationSource = $this->objectManager->get(\Neos\Flow\Configuration\Source\YamlSource::class); $routesConfiguration = $configurationSource->load($this->packageManager->getPackage('Neos.Setup')->getConfigurationPath() . ConfigurationManager::CONFIGURATION_TYPE_ROUTES); $this->router->setRoutesConfiguration($routesConfiguration); $componentContext->setParameter(\Neos\Flow\Mvc\Routing\RoutingComponent::class, 'skipRouterInitialization', true); }
/** * Adds all validators that extend the AssetValidatorInterface. * * @return void */ protected function initializeObject() { $assetValidatorImplementationClassNames = $this->reflectionService->getAllImplementationClassNamesForInterface(AssetValidatorInterface::class); foreach ($assetValidatorImplementationClassNames as $assetValidatorImplementationClassName) { $this->addValidator($this->objectManager->get($assetValidatorImplementationClassName)); } }
/** * @param array $chainConfiguration * @return ComponentChain * @throws Exception */ public function create(array $chainConfiguration) { if (empty($chainConfiguration)) { return null; } $arraySorter = new PositionalArraySorter($chainConfiguration); $sortedChainConfiguration = $arraySorter->toArray(); $chainComponents = []; foreach ($sortedChainConfiguration as $componentName => $configuration) { $componentOptions = isset($configuration['componentOptions']) ? $configuration['componentOptions'] : []; if (isset($configuration['chain'])) { $component = $this->create($configuration['chain']); } else { if (!isset($configuration['component'])) { throw new Exception(sprintf('Component chain could not be created because no component class name is configured for component "%s"', $componentName), 1401718283); } $component = $this->objectManager->get($configuration['component'], $componentOptions); if (!$component instanceof ComponentInterface) { throw new Exception(sprintf('Component chain could not be created because the class "%s" does not implement the ComponentInterface, in component "%s" does not implement', $configuration['component'], $componentName), 1401718283); } } $chainComponents[] = $component; } return new ComponentChain(['components' => $chainComponents]); }
/** * @return void */ public function initializeObject() { // flush routing caches if in Development context & routing settings changed if ($this->objectManager->getContext()->isDevelopment() && $this->routeCache->get('routingSettings') !== $this->routingSettings) { $this->flushCaches(); $this->routeCache->set('routingSettings', $this->routingSettings); } }
/** * This object is created very early and is part of the blacklisted "Neos\Flow\Aop" namespace so we can't rely on AOP for the property injection. * * @param ObjectManagerInterface $objectManager * @return void */ public function injectObjectManager(ObjectManagerInterface $objectManager) { if ($this->objectManager === null) { $this->objectManager = $objectManager; /** @var CacheManager $cacheManager */ $cacheManager = $this->objectManager->get(CacheManager::class); $this->runtimeExpressionsCache = $cacheManager->getCache('Flow_Aop_RuntimeExpressions'); $this->runtimeExpressions = $this->runtimeExpressionsCache->requireOnce('Flow_Aop_RuntimeExpressions'); } }
/** * Prepare test objects */ protected function setUp() { $this->nodeFactory = $this->getMockBuilder(NodeFactory::class)->setMethods(array('filterNodeByContext'))->getMock(); $this->nodeFactory->expects(self::any())->method('filterNodeByContext')->willReturnArgument(0); $this->reflectionServiceMock = $this->createMock(ReflectionService::class); $this->reflectionServiceMock->expects(self::any())->method('getAllImplementationClassNamesForInterface')->with(NodeInterface::class)->willReturn(array(Node::class)); $this->objectManagerMock = $this->createMock(ObjectManagerInterface::class); $this->objectManagerMock->expects(self::any())->method('get')->with(ReflectionService::class)->willReturn($this->reflectionServiceMock); $this->objectManagerMock->expects(self::any())->method('getClassNameByObjectName')->with(NodeInterface::class)->willReturn(Node::class); $this->inject($this->nodeFactory, 'objectManager', $this->objectManagerMock); }
/** * Resolves the class name of an authentication provider. If a valid provider class name is given, it is just returned. * * @param string $providerName The (short) name of the provider * @return string The object name of the authentication provider * @throws NoAuthenticationProviderFoundException */ public function resolveProviderClass($providerName) { $resolvedObjectName = $this->objectManager->getCaseSensitiveObjectName($providerName); if ($resolvedObjectName !== false) { return $resolvedObjectName; } $resolvedObjectName = $this->objectManager->getCaseSensitiveObjectName('Neos\\Flow\\Security\\Authentication\\Provider\\' . $providerName); if ($resolvedObjectName !== false) { return $resolvedObjectName; } throw new NoAuthenticationProviderFoundException('An authentication provider with the name "' . $providerName . '" could not be resolved.', 1217154134); }
/** * Resolves the class name of a request pattern. If a valid request pattern class name is given, it is just returned. * * @param string $name The (short) name of the pattern * @return string The class name of the request pattern, NULL if no class was found. * @throws Exception\NoRequestPatternFoundException */ public function resolveRequestPatternClass($name) { $resolvedObjectName = $this->objectManager->getCaseSensitiveObjectName($name); if ($resolvedObjectName !== false) { return $resolvedObjectName; } $resolvedObjectName = $this->objectManager->getCaseSensitiveObjectName('Neos\\Flow\\Security\\RequestPattern\\' . $name); if ($resolvedObjectName !== false) { return $resolvedObjectName; } throw new Exception\NoRequestPatternFoundException('A request pattern with the name: "' . $name . '" could not be resolved.', 1217154134); }
/** * Resolves the class name of a security interceptor. If a valid interceptor class name is given, it is just returned. * * @param string $name The (short) name of the interceptor * @return string The class name of the security interceptor, NULL if no class was found. * @throws NoInterceptorFoundException */ public function resolveInterceptorClass($name) { $resolvedObjectName = $this->objectManager->getCaseSensitiveObjectName($name); if ($resolvedObjectName !== false) { return $resolvedObjectName; } $resolvedObjectName = $this->objectManager->getCaseSensitiveObjectName('Neos\\Flow\\Security\\Authorization\\Interceptor\\' . $name); if ($resolvedObjectName !== false) { return $resolvedObjectName; } throw new NoInterceptorFoundException('A security interceptor with the name: "' . $name . '" could not be resolved.', 1217154134); }
/** * @test */ public function ifCommandCantBeResolvedTheHelpScreenIsShown() { // The following call is only made to satisfy PHPUnit. For some weird reason PHPUnit complains that the // mocked method ("getObjectNameByClassName") does not exist _if the mock object is not used_. $this->mockObjectManager->getObjectNameByClassName('Acme\\Test\\Command\\DefaultCommandController'); $this->mockCommandManager->getCommandByIdentifier('acme.test:default:list'); $mockCommandManager = $this->createMock(Cli\CommandManager::class); $mockCommandManager->expects($this->any())->method('getCommandByIdentifier')->with('test:default:list')->will($this->throwException(new NoSuchCommandException())); $this->requestBuilder->injectCommandManager($mockCommandManager); $request = $this->requestBuilder->build('test:default:list'); $this->assertSame(HelpCommandController::class, $request->getControllerObjectName()); }
/** * Merge the default plugin arguments of the Plugin with the arguments in the request * and generate a controllerObjectName * * @param object $request * @param array $arguments * @return string $controllerObjectName */ public function getControllerObjectName($request, array $arguments) { $controllerName = $arguments['controllerName'] !== null ? $arguments['controllerName'] : $request->getControllerName(); $subPackageKey = $arguments['subPackageKey'] !== null ? $arguments['subPackageKey'] : $request->getControllerSubpackageKey(); $packageKey = $arguments['packageKey'] !== null ? $arguments['packageKey'] : $request->getControllerPackageKey(); $possibleObjectName = '@package\\@subpackage\\Controller\\@controllerController'; $possibleObjectName = str_replace('@package', str_replace('.', '\\', $packageKey), $possibleObjectName); $possibleObjectName = str_replace('@subpackage', $subPackageKey, $possibleObjectName); $possibleObjectName = str_replace('@controller', $controllerName, $possibleObjectName); $possibleObjectName = str_replace('\\\\', '\\', $possibleObjectName); $controllerObjectName = $this->objectManager->getCaseSensitiveObjectName($possibleObjectName); return $controllerObjectName !== false ? $controllerObjectName : ''; }
/** * Execute the job * * A job should finish itself after successful execution using the queue methods. * * @param QueueInterface $queue * @param Message $message * @return boolean TRUE If the execution was successful * @throws \Exception */ public function execute(QueueInterface $queue, Message $message) { $service = $this->objectManager->get($this->className); $this->deferMethodCallAspect->setProcessingJob(true); try { $methodName = $this->methodName; call_user_func_array([$service, $methodName], $this->arguments); return true; } catch (\Exception $exception) { $this->deferMethodCallAspect->setProcessingJob(false); throw $exception; } }
/** * @return void */ public function setUp() { parent::setup(); vfsStream::setup('Foo'); $this->httpRequest = Http\Request::create(new Http\Uri('http://localhost')); $this->httpResponse = new Http\Response(); $mockRequestHandler = $this->createMock(Http\RequestHandler::class); $mockRequestHandler->expects($this->any())->method('getHttpRequest')->will($this->returnValue($this->httpRequest)); $mockRequestHandler->expects($this->any())->method('getHttpResponse')->will($this->returnValue($this->httpResponse)); $this->mockBootstrap = $this->createMock(Bootstrap::class); $this->mockBootstrap->expects($this->any())->method('getActiveRequestHandler')->will($this->returnValue($mockRequestHandler)); $this->mockSecurityContext = $this->createMock(Context::class); $this->mockObjectManager = $this->createMock(ObjectManagerInterface::class); $this->mockObjectManager->expects($this->any())->method('get')->with(Context::class)->will($this->returnValue($this->mockSecurityContext)); }
/** * Get available data source implementations * * @param ObjectManagerInterface $objectManager * @return array Data source class names indexed by identifier * @Flow\CompileStatic * @throws NeosException */ public static function getDataSources($objectManager) { $reflectionService = $objectManager->get(ReflectionService::class); $dataSources = array(); $dataSourceClassNames = $reflectionService->getAllImplementationClassNamesForInterface(DataSourceInterface::class); /** @var $dataSourceClassName DataSourceInterface */ foreach ($dataSourceClassNames as $dataSourceClassName) { $identifier = $dataSourceClassName::getIdentifier(); if (isset($dataSources[$identifier])) { throw new NeosException(sprintf('Data source with identifier "%s" is already defined in class %s.', $identifier, $dataSourceClassName), 1414088185); } $dataSources[$identifier] = $dataSourceClassName; } return $dataSources; }
/** * Returns the static value of the given operand, this might be also a global object * * @param mixed $expression The expression string representing the operand * @return mixed The calculated value */ public function getValueForOperand($expression) { if (is_array($expression)) { $result = []; foreach ($expression as $expressionEntry) { $result[] = $this->getValueForOperand($expressionEntry); } return $result; } elseif (is_numeric($expression)) { return $expression; } elseif ($expression === true) { return true; } elseif ($expression === false) { return false; } elseif ($expression === null) { return null; } elseif (strpos($expression, 'context.') === 0) { $objectAccess = explode('.', $expression, 3); $globalObjectsRegisteredClassName = $this->globalObjects[$objectAccess[1]]; $globalObject = $this->objectManager->get($globalObjectsRegisteredClassName); $this->securityContext->withoutAuthorizationChecks(function () use($globalObject, $objectAccess, &$globalObjectValue) { $globalObjectValue = $this->getObjectValueByPath($globalObject, $objectAccess[2]); }); return $globalObjectValue; } else { return trim($expression, '"\''); } }
/** * Sets up this test case */ public function setUp() { $this->dispatcher = $this->getMockBuilder(Dispatcher::class)->disableOriginalConstructor()->setMethods(['resolveController'])->getMock(); $this->mockActionRequest = $this->getMockBuilder(ActionRequest::class)->disableOriginalConstructor()->getMock(); $this->mockActionRequest->expects($this->any())->method('isMainRequest')->will($this->returnValue(false)); $this->mockParentRequest = $this->getMockBuilder(ActionRequest::class)->disableOriginalConstructor()->getMock(); $this->mockActionRequest->expects($this->any())->method('getParentRequest')->will($this->returnValue($this->mockParentRequest)); $this->mockMainRequest = $this->getMockBuilder(ActionRequest::class)->disableOriginalConstructor()->getMock(); $this->mockActionRequest->expects($this->any())->method('getMainRequest')->will($this->returnValue($this->mockMainRequest)); $this->mockHttpRequest = $this->getMockBuilder(HttpRequest::class)->disableOriginalConstructor()->getMock(); $this->mockActionRequest->expects($this->any())->method('getHttpRequest')->will($this->returnValue($this->mockHttpRequest)); $this->mockHttpResponse = $this->getMockBuilder(HttpResponse::class)->disableOriginalConstructor()->getMock(); $this->mockController = $this->getMockBuilder(ControllerInterface::class)->setMethods(['processRequest'])->getMock(); $this->dispatcher->expects($this->any())->method('resolveController')->will($this->returnValue($this->mockController)); $this->mockSecurityContext = $this->getMockBuilder(Context::class)->disableOriginalConstructor()->getMock(); $this->mockFirewall = $this->getMockBuilder(FirewallInterface::class)->getMock(); $this->mockSecurityLogger = $this->getMockBuilder(SecurityLoggerInterface::class)->getMock(); $this->mockObjectManager = $this->getMockBuilder(ObjectManagerInterface::class)->getMock(); $this->mockObjectManager->expects($this->any())->method('get')->will($this->returnCallback(function ($className) { if ($className === Context::class) { return $this->mockSecurityContext; } elseif ($className === FirewallInterface::class) { return $this->mockFirewall; } elseif ($className === SecurityLoggerInterface::class) { return $this->mockSecurityLogger; } return null; })); $this->inject($this->dispatcher, 'objectManager', $this->mockObjectManager); }
/** * Handle an Exception thrown while rendering TypoScript according to * settings specified in Neos.Fusion.rendering.exceptionHandler * * @param array $typoScriptPath * @param \Exception $exception * @param boolean $useInnerExceptionHandler * @return string * @throws InvalidConfigurationException */ public function handleRenderingException($typoScriptPath, \Exception $exception, $useInnerExceptionHandler = false) { $typoScriptConfiguration = $this->getConfigurationForPath($typoScriptPath); if (isset($typoScriptConfiguration['__meta']['exceptionHandler'])) { $exceptionHandlerClass = $typoScriptConfiguration['__meta']['exceptionHandler']; $invalidExceptionHandlerMessage = 'The class "%s" is not valid for property "@exceptionHandler".'; } else { if ($useInnerExceptionHandler === true) { $exceptionHandlerClass = $this->settings['rendering']['innerExceptionHandler']; } else { $exceptionHandlerClass = $this->settings['rendering']['exceptionHandler']; } $invalidExceptionHandlerMessage = 'The class "%s" is not valid for setting "Neos.Fusion.rendering.exceptionHandler".'; } $exceptionHandler = null; if ($this->objectManager->isRegistered($exceptionHandlerClass)) { $exceptionHandler = $this->objectManager->get($exceptionHandlerClass); } if ($exceptionHandler === null || !$exceptionHandler instanceof AbstractRenderingExceptionHandler) { $message = sprintf($invalidExceptionHandlerMessage . "\n" . 'Please specify a fully qualified classname to a subclass of %2$s\\AbstractRenderingExceptionHandler.' . "\n" . 'You might implement an own handler or use one of the following:' . "\n" . '%2$s\\AbsorbingHandler' . "\n" . '%2$s\\HtmlMessageHandler' . "\n" . '%2$s\\PlainTextHandler' . "\n" . '%2$s\\ThrowingHandler' . "\n" . '%2$s\\XmlCommentHandler', $exceptionHandlerClass, 'Neos\\Fusion\\Core\\ExceptionHandlers'); throw new InvalidConfigurationException($message, 1368788926); } $exceptionHandler->setRuntime($this); if (array_key_exists('__objectType', $typoScriptConfiguration)) { $typoScriptPath .= sprintf('<%s>', $typoScriptConfiguration['__objectType']); } $output = $exceptionHandler->handleRenderingException($typoScriptPath, $exception); return $output; }
/** * Emits a signal when an Advice is invoked * * The advice is not proxyable, so the signal is dispatched manually here. * * @param object $aspectObject * @param string $methodName * @param JoinPointInterface $joinPoint * @return void * @Flow\Signal */ protected function emitAdviceInvoked($aspectObject, $methodName, $joinPoint) { if ($this->dispatcher === null) { $this->dispatcher = $this->objectManager->get(Dispatcher::class); } $this->dispatcher->dispatch(self::class, 'adviceInvoked', [$aspectObject, $methodName, $joinPoint]); }
/** * @test */ public function validatePasswordWillUseStrategyIdentifierFromHashedPassword() { $mockStrategy = $this->createMock(PasswordHashingStrategyInterface::class); $this->mockObjectManager->expects($this->any())->method('get')->will($this->returnValue($mockStrategy)); $mockStrategy->expects($this->atLeastOnce())->method('validatePassword')->with('myTestPassword', '---hashed-password---')->will($this->returnValue(true)); $result = $this->hashService->validatePassword('myTestPassword', 'TestStrategy=>---hashed-password---'); $this->assertEquals(true, $result); }
/** * @test */ public function resolveValidatorObjectNameCanResolveShortNamesOfBuiltInValidators() { $this->mockObjectManager->expects($this->at(0))->method('get')->with(ReflectionService::class)->will($this->returnValue($this->mockReflectionService)); $this->mockObjectManager->expects($this->at(1))->method('isRegistered')->with('Foo')->will($this->returnValue(false)); $this->mockObjectManager->expects($this->at(2))->method('isRegistered')->with('Neos\\Flow\\Validation\\Validator\\FooValidator')->will($this->returnValue(true)); $this->mockReflectionService->expects($this->any())->method('getAllImplementationClassNamesForInterface')->with(ValidatorInterface::class)->will($this->returnValue(['Neos\\Flow\\Validation\\Validator\\FooValidator'])); $this->assertSame('Neos\\Flow\\Validation\\Validator\\FooValidator', $this->validatorResolver->_call('resolveValidatorObjectName', 'Foo')); }
/** * Starts the shutdown sequence * * @param string $runlevel one of the Bootstrap::RUNLEVEL_* constants * @return void */ protected function shutdown($runlevel) { $this->bootstrap->shutdown($runlevel); if ($runlevel === Bootstrap::RUNLEVEL_COMPILETIME) { $this->objectManager->get(LockManager::class)->unlockSite(); } exit($this->response->getExitCode()); }
/** * Adds a setting filter to the pointcut filter composite * * @param string $operator The operator * @param string $configurationPath The path to the settings option, that should be used * @param PointcutFilterComposite $pointcutFilterComposite An instance of the pointcut filter composite. The result (ie. the custom filter) will be added to this composite object. * @return void */ protected function parseDesignatorSetting($operator, $configurationPath, PointcutFilterComposite $pointcutFilterComposite) { $filter = new PointcutSettingFilter($configurationPath); /** @var ConfigurationManager $configurationManager */ $configurationManager = $this->objectManager->get(ConfigurationManager::class); $filter->injectConfigurationManager($configurationManager); $pointcutFilterComposite->addFilter($operator, $filter); }
/** * Matches a \Neos\Flow\Mvc\RequestInterface against the configured CSRF pattern rules and * searches for invalid csrf tokens. If this returns TRUE, the request is invalid! * * @param RequestInterface $request The request that should be matched * @return boolean TRUE if the pattern matched, FALSE otherwise * @throws AuthenticationRequiredException */ public function matchRequest(RequestInterface $request) { if (!$request instanceof ActionRequest || $request->getHttpRequest()->isMethodSafe()) { $this->systemLogger->log('CSRF: No token required, safe request', LOG_DEBUG); return false; } if ($this->authenticationManager->isAuthenticated() === false) { $this->systemLogger->log('CSRF: No token required, not authenticated', LOG_DEBUG); return false; } if ($this->securityContext->areAuthorizationChecksDisabled() === true) { $this->systemLogger->log('CSRF: No token required, authorization checks are disabled', LOG_DEBUG); return false; } $controllerClassName = $this->objectManager->getClassNameByObjectName($request->getControllerObjectName()); $actionMethodName = $request->getControllerActionName() . 'Action'; if (!$this->hasPolicyEntryForMethod($controllerClassName, $actionMethodName)) { $this->systemLogger->log(sprintf('CSRF: No token required, method %s::%s() is not restricted by a policy.', $controllerClassName, $actionMethodName), LOG_DEBUG); return false; } if ($this->reflectionService->isMethodTaggedWith($controllerClassName, $actionMethodName, 'skipcsrfprotection')) { $this->systemLogger->log(sprintf('CSRF: No token required, method %s::%s() is tagged with a "skipcsrfprotection" annotation', $controllerClassName, $actionMethodName), LOG_DEBUG); return false; } $httpRequest = $request->getHttpRequest(); if ($httpRequest->hasHeader('X-Flow-Csrftoken')) { $csrfToken = $httpRequest->getHeader('X-Flow-Csrftoken'); } else { $internalArguments = $request->getMainRequest()->getInternalArguments(); $csrfToken = isset($internalArguments['__csrfToken']) ? $internalArguments['__csrfToken'] : null; } if (empty($csrfToken)) { $this->systemLogger->log(sprintf('CSRF: token was empty but a valid token is required for %s::%s()', $controllerClassName, $actionMethodName), LOG_DEBUG); return true; } if (!$this->securityContext->hasCsrfProtectionTokens()) { throw new AuthenticationRequiredException(sprintf('CSRF: No CSRF tokens in security context, possible session timeout. A valid token is required for %s::%s()', $controllerClassName, $actionMethodName), 1317309673); } if ($this->securityContext->isCsrfProtectionTokenValid($csrfToken) === false) { $this->systemLogger->log(sprintf('CSRF: token was invalid but a valid token is required for %s::%s()', $controllerClassName, $actionMethodName), LOG_DEBUG); return true; } $this->systemLogger->log(sprintf('CSRF: Successfully verified token for %s::%s()', $controllerClassName, $actionMethodName), LOG_DEBUG); return false; }
/** * @test */ public function convertFromReturnsNullIfResourcePropertyIsNotConverted() { $this->mockObjectManager->expects($this->any())->method('getClassNameByObjectName')->will($this->returnCallback(function ($objectType) { return $objectType; })); $configuration = new PropertyMappingConfiguration(); $configuration->setTypeConverterOption(ImageInterfaceConverter::class, PersistentObjectConverter::CONFIGURATION_CREATION_ALLOWED, true); $this->assertNull($this->converter->convertFrom(array(), Image::class, array(), $configuration)); }
/** * Emits a signal when a Request has been dispatched * * The action request is not proxyable, so the signal is dispatched manually here. * The safeguard allows unit tests without the dispatcher dependency. * * @param ActionRequest $request * @return void * @Flow\Signal */ protected function emitRequestDispatched($request) { if ($this->objectManager !== null) { $dispatcher = $this->objectManager->get(SignalSlotDispatcher::class); if ($dispatcher !== null) { $dispatcher->dispatch(ActionRequest::class, 'requestDispatched', [$request]); } } }
/** * Returns the object name of the controller defined by the package, subpackage key and * controller name * * @param string $packageKey the package key of the controller * @param string $subPackageKey the subpackage key of the controller * @param string $controllerName the controller name excluding the "Controller" suffix * @return string The controller's Object Name or NULL if the controller does not exist */ protected function getControllerObjectName($packageKey, $subPackageKey, $controllerName) { $possibleObjectName = '@package\\@subpackage\\Controller\\@controllerController'; $possibleObjectName = str_replace('@package', str_replace('.', '\\', $packageKey), $possibleObjectName); $possibleObjectName = str_replace('@subpackage', $subPackageKey, $possibleObjectName); $possibleObjectName = str_replace('@controller', $controllerName, $possibleObjectName); $possibleObjectName = str_replace('\\\\', '\\', $possibleObjectName); $controllerObjectName = $this->objectManager->getCaseSensitiveObjectName($possibleObjectName); return $controllerObjectName !== false ? $controllerObjectName : null; }
/** * @test */ public function parseSetsDefaultValueOfRoutePartsRecursively() { $this->route->setUriPattern('{foo.bar}'); $this->route->setRoutePartsConfiguration(['foo.bar' => ['handler' => 'SomeRoutePartHandler']]); $this->route->setDefaults(['foo' => ['bar' => 'SomeDefaultValue']]); $mockRoutePartHandler = $this->createMock(Routing\DynamicRoutePartInterface::class); $mockRoutePartHandler->expects($this->once())->method('setDefaultValue')->with('SomeDefaultValue'); $this->mockObjectManager->expects($this->once())->method('get')->with('SomeRoutePartHandler')->will($this->returnValue($mockRoutePartHandler)); $this->route->parse(); }
/** * @param PropertyMappingConfiguration $propertyMappingConfiguration * @param string $dataType * @return boolean */ protected function setTypeConverterForType(PropertyMappingConfiguration $propertyMappingConfiguration, $dataType) { if (!isset($this->typesConfiguration[$dataType]) || !isset($this->typesConfiguration[$dataType]['typeConverter'])) { return false; } $typeConverter = $this->objectManager->get($this->typesConfiguration[$dataType]['typeConverter']); $propertyMappingConfiguration->setTypeConverter($typeConverter); $this->setTypeConverterOptionsForType($propertyMappingConfiguration, $this->typesConfiguration[$dataType]['typeConverter'], $dataType); return true; }
/** * @When /^I import the last exported site$/ */ public function iImportTheLastExportedSite() { // Persist any pending entity insertions (caused by lazy creation of live Workspace) // This is a workaround which should be solved by properly isolating all read-only steps $this->getSubContext('flow')->persistAll(); $this->resetNodeInstances(); /** @var SiteImportService $siteImportService */ $siteImportService = $this->objectManager->get(SiteImportService::class); $siteImportService->importFromFile($this->lastExportedSiteXmlPathAndFilename); }