/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
}
/**
* Additional setup: Routes
*/
public function setUp()
{
parent::setUp();
$this->registerRoute('viewsconfigurationa', 'test/mvc/viewsconfigurationa(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\ViewsConfiguration\\Fixtures', '@controller' => 'ViewsConfigurationTestA', '@action' => 'first', '@format' => 'html']);
$this->registerRoute('viewsconfigurationb', 'test/mvc/viewsconfigurationb(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\ViewsConfiguration\\Fixtures', '@controller' => 'ViewsConfigurationTestB', '@action' => 'first', '@format' => 'html']);
$this->registerRoute('viewsconfigurationc', 'test/mvc/viewsconfigurationc(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\ViewsConfiguration\\Fixtures', '@controller' => 'ViewsConfigurationTestC', '@action' => 'index', '@format' => 'html']);
}
/**
*/
public function setUp()
{
parent::setUp();
$this->partyRepository = $this->objectManager->get(PartyRepository::class);
$this->accountRepository = $this->objectManager->get(AccountRepository::class);
$this->accountFactory = $this->objectManager->get(AccountFactory::class);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$this->currentUserWorkspace = uniqid('user-', true);
$this->currentGroupWorkspace = uniqid('group-', true);
$this->setUpRootNodeAndRepository();
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
//
// create a mock packageManager that only returns the the packages that contain schema files
//
$schemaPackages = [];
$configurationPackages = [];
// get all packages and select the ones we want to test
$temporaryPackageManager = $this->objectManager->get(PackageManagerInterface::class);
foreach ($temporaryPackageManager->getActivePackages() as $package) {
if (in_array($package->getPackageKey(), $this->getSchemaPackageKeys())) {
$schemaPackages[$package->getPackageKey()] = $package;
}
if (in_array($package->getPackageKey(), $this->getConfigurationPackageKeys())) {
$configurationPackages[$package->getPackageKey()] = $package;
}
}
$this->mockPackageManager = $this->createMock(PackageManager::class);
$this->mockPackageManager->expects($this->any())->method('getActivePackages')->will($this->returnValue($schemaPackages));
//
// create mock configurationManager and store the original one
//
$this->originalConfigurationManager = $this->objectManager->get(ConfigurationManager::class);
$yamlConfigurationSource = $this->objectManager->get(\Neos\Flow\Tests\Functional\Configuration\Fixtures\RootDirectoryIgnoringYamlSource::class);
$this->mockConfigurationManager = clone $this->originalConfigurationManager;
$this->mockConfigurationManager->setPackages($configurationPackages);
$this->inject($this->mockConfigurationManager, 'configurationSource', $yamlConfigurationSource);
$this->objectManager->setInstance(ConfigurationManager::class, $this->mockConfigurationManager);
//
// create the configurationSchemaValidator
//
$this->configurationSchemaValidator = $this->objectManager->get(ConfigurationSchemaValidator::class);
$this->inject($this->configurationSchemaValidator, 'configurationManager', $this->mockConfigurationManager);
}
/**
* Additional setup: Routes
*/
public function setUp()
{
parent::setUp();
$this->registerRoute('testa', 'test/mvc/actioncontrollertesta(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\Fixtures', '@controller' => 'ActionControllerTestA', '@action' => 'first', '@format' => 'html']);
$this->registerRoute('testb', 'test/mvc/actioncontrollertestb(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\Fixtures', '@controller' => 'ActionControllerTestB', '@action' => 'first', '@format' => 'html']);
$route = $this->registerRoute('testc', 'test/mvc/actioncontrollertestc/{entity}(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\Fixtures', '@controller' => 'Entity', '@action' => 'show', '@format' => 'html']);
$route->setRoutePartsConfiguration(['entity' => ['objectType' => \Neos\Flow\Tests\Functional\Persistence\Fixtures\TestEntity::class]]);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof \Neos\Flow\Persistence\Doctrine\PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
$this->postRepository = $this->objectManager->get(\Neos\Flow\Tests\Functional\Persistence\Fixtures\PostRepository::class);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
$this->resourceManager = $this->objectManager->get(ResourceManager::class);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
$this->testEntityRepository = $this->objectManager->get(Fixtures\TestEntityRepository::class);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$workspaceRepository = $this->objectManager->get(WorkspaceRepository::class);
$workspaceRepository->add(new Workspace('live'));
$this->persistenceManager->persistAll();
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
$this->context = $this->contextFactory->create(array('workspaceName' => 'live'));
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
$this->testEntityRepository = new Fixtures\TestEntityRepository();
$this->extendedTypesEntityRepository = new Fixtures\ExtendedTypesEntityRepository();
}
/**
* Initializer
*/
public function setUp()
{
parent::setUp();
$route = new \Neos\Flow\Mvc\Routing\Route();
$route->setUriPattern('test/fluid/formobjects(/{@action})');
$route->setDefaults(array('@package' => 'Neos.FluidAdaptor', '@subpackage' => 'Tests\\Functional\\Form\\Fixtures', '@controller' => 'Form', '@action' => 'index', '@format' => 'html'));
$route->setAppendExceedingArguments(true);
$this->router->addRoute($route);
}
/**
* Initializer
*/
public function setUp()
{
parent::setUp();
$route = new \Neos\Flow\Mvc\Routing\Route();
$route->setUriPattern('test/form/simpleform/{formFactoryClassName}');
$route->setDefaults(array('@package' => 'Neos.Form', '@subpackage' => 'Tests\\Functional\\Fixtures', '@controller' => 'Form', '@action' => 'index', '@format' => 'html'));
$route->setAppendExceedingArguments(true);
$this->router->addRoute($route);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
$this->testEntityRepository = $this->objectManager->get(Fixtures\TestEntityRepository::class);
$this->registerRoute('post', 'test/validation/entity/{@action}', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\Fixtures', '@controller' => 'Entity', '@format' => 'html']);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$route = new Route();
$route->setName('Functional Test - Session::SessionTest');
$route->setUriPattern('test/session(/{@action})');
$route->setDefaults(['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Session\\Fixtures', '@controller' => 'SessionTest', '@action' => 'sessionStart', '@format' => 'html']);
$this->router->addRoute($route);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$route = new Route();
$route->setName('Functional Test - Http::Client::InternalRequestEngine');
$route->setUriPattern('test/security/restricted');
$route->setDefaults(['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Security\\Fixtures', '@controller' => 'Restricted', '@action' => 'admin', '@format' => 'html']);
$this->router->addRoute($route);
}
/**
* Additional setup: Routes
*/
public function setUp()
{
parent::setUp();
$route = new Route();
$route->setName('AbstractControllerTest Route 1');
$route->setUriPattern('test/mvc/abstractcontrollertesta/{@action}');
$route->setDefaults(['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Mvc\\Fixtures', '@controller' => 'AbstractControllerTestA', '@format' => 'html']);
$route->setAppendExceedingArguments(true);
$this->router->addRoute($route);
}
/**
* Additional setup: Routes
*/
public function setUp()
{
parent::setUp();
$route = new Route();
$route->setName('WidgetTest');
$route->setUriPattern('test/widget/{@controller}(/{@action})');
$route->setDefaults(array('@package' => 'Neos.FluidAdaptor', '@subpackage' => 'Tests\\Functional\\Core\\Fixtures', '@action' => 'index', '@format' => 'html'));
$route->setAppendExceedingArguments(true);
$this->router->addRoute($route);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$accountRepository = $this->objectManager->get(AccountRepository::class);
$accountFactory = $this->objectManager->get(AccountFactory::class);
$account = $accountFactory->createAccountWithPassword('admin', 'password', ['Neos.Flow:Administrator'], 'UsernamePasswordTestingProvider');
$accountRepository->add($account);
$this->persistenceManager->persistAll();
$this->registerRoute('authentication', 'test/security/authentication/usernamepassword(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Security\\Fixtures', '@controller' => 'UsernamePasswordTest', '@action' => 'authenticate', '@format' => 'html']);
$this->registerRoute('controller', 'test/security/restricted(/{@action})', ['@package' => 'Neos.Flow', '@subpackage' => 'Tests\\Functional\\Security\\Fixtures', '@controller' => 'Restricted', '@action' => 'public', '@format' => 'html'], true);
}
public function setUp()
{
parent::setUp();
$this->markSkippedIfNodeTypesPackageIsNotInstalled();
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
$contentContext = $this->contextFactory->create(array('workspaceName' => 'live'));
$this->siteImportService = $this->objectManager->get(SiteImportService::class);
$this->siteExportService = $this->objectManager->get(SiteExportService::class);
$this->importedSite = $this->siteImportService->importFromFile(__DIR__ . '/' . $this->fixtureFileName, $contentContext);
$this->persistenceManager->persistAll();
}
public function setUp()
{
parent::setUp();
$this->persistedUsernamePasswordProvider = new PersistedUsernamePasswordProvider('myTestProvider');
$this->accountFactory = new Security\AccountFactory();
$this->accountRepository = new Security\AccountRepository();
$this->authenticationToken = $this->getAccessibleMock(Security\Authentication\Token\UsernamePassword::class, array('dummy'));
$account = $this->accountFactory->createAccountWithPassword('username', 'password', array(), 'myTestProvider');
$this->accountRepository->add($account);
$this->persistenceManager->persistAll();
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$this->nodeTypeManager = $this->objectManager->get(NodeTypeManager::class);
$this->liveWorkspace = new Workspace('live');
$this->workspaceRepository = $this->objectManager->get(WorkspaceRepository::class);
$this->workspaceRepository->add($this->liveWorkspace);
$this->persistenceManager->persistAll();
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
$this->context = $this->contextFactory->create(['workspaceName' => 'live']);
$this->nodeDataRepository = $this->objectManager->get(NodeDataRepository::class);
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$this->nodeDataRepository = new NodeDataRepository();
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
$this->nodeTypeManager = $this->objectManager->get(NodeTypeManager::class);
$workspace = new Workspace('live');
$this->objectManager->get(WorkspaceRepository::class)->add($workspace);
$this->persistenceManager->persistAll();
$context = $this->contextFactory->create(array('workspaceName' => 'live'));
$this->rootNode = $context->getRootNode();
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
if (!$this->persistenceManager instanceof PersistenceManager) {
$this->markTestSkipped('Doctrine persistence is not enabled');
}
$this->restrictableEntityDoctrineRepository = new Fixtures\RestrictableEntityDoctrineRepository();
$this->testEntityADoctrineRepository = new Fixtures\TestEntityADoctrineRepository();
$this->testEntityCDoctrineRepository = new Fixtures\TestEntityCDoctrineRepository();
$this->testEntityDDoctrineRepository = new Fixtures\TestEntityDDoctrineRepository();
$this->globalObjectTestContext = $this->objectManager->get(Aop\Fixtures\TestContext::class);
}
/**
* Set up dependencies
*/
public function setUp()
{
parent::setUp();
$configurationManager = $this->objectManager->get(ConfigurationManager::class);
$packageKey = $this->objectManager->getPackageKeyByObjectName(TypeHandling::getTypeForValue($this));
$packageSettings = $configurationManager->getConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $packageKey);
if (!isset($packageSettings['testing']['enabled']) || $packageSettings['testing']['enabled'] !== true) {
$this->markTestSkipped(sprintf('Queue is not configured (%s.testing.enabled != TRUE)', $packageKey));
}
$this->queueSettings = $packageSettings['testing'];
$this->queue = $this->getQueue();
$this->queue->setUp();
$this->queue->flush();
}
public function setUp()
{
parent::setUp();
$this->router->setRoutesConfiguration(null);
$this->nodeDataRepository = $this->objectManager->get(NodeDataRepository::class);
$domainRepository = $this->objectManager->get(DomainRepository::class);
$siteRepository = $this->objectManager->get(SiteRepository::class);
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
$contextProperties = array('workspaceName' => 'live');
$contentContext = $this->contextFactory->create($contextProperties);
$siteImportService = $this->objectManager->get(SiteImportService::class);
$siteImportService->importFromFile(__DIR__ . '/../../Fixtures/NodeStructure.xml', $contentContext);
$this->persistenceManager->persistAll();
/** @var Domain $currentDomain */
$currentDomain = $domainRepository->findOneByActiveRequest();
if ($currentDomain !== null) {
$contextProperties['currentSite'] = $currentDomain->getSite();
$contextProperties['currentDomain'] = $currentDomain;
} else {
$contextProperties['currentSite'] = $siteRepository->findFirst();
}
$contentContext = $this->contextFactory->create($contextProperties);
$this->contentContext = $contentContext;
$this->propertyMapper = $this->objectManager->get(PropertyMapper::class);
$this->viewHelper = new NodeViewHelper();
/** @var $requestHandler FunctionalTestRequestHandler */
$requestHandler = self::$bootstrap->getActiveRequestHandler();
$httpRequest = $requestHandler->getHttpRequest();
$httpRequest->setBaseUri(new Uri('http://neos.test/'));
$controllerContext = new ControllerContext(new ActionRequest($httpRequest), $requestHandler->getHttpResponse(), new Arguments(array()), new UriBuilder());
$this->inject($this->viewHelper, 'controllerContext', $controllerContext);
$typoScriptObject = $this->getAccessibleMock(TemplateImplementation::class, array('dummy'), array(), '', false);
$this->tsRuntime = new Runtime(array(), $controllerContext);
$this->tsRuntime->pushContextArray(array('documentNode' => $this->contentContext->getCurrentSiteNode()->getNode('home'), 'alternativeDocumentNode' => $this->contentContext->getCurrentSiteNode()->getNode('home/about-us/mission')));
$this->inject($typoScriptObject, 'tsRuntime', $this->tsRuntime);
/** @var AbstractTemplateView|\PHPUnit_Framework_MockObject_MockObject $mockView */
$mockView = $this->getAccessibleMock(FluidView::class, array(), array(), '', false);
$mockView->expects($this->any())->method('getTypoScriptObject')->will($this->returnValue($typoScriptObject));
$viewHelperVariableContainer = new ViewHelperVariableContainer();
$viewHelperVariableContainer->setView($mockView);
$this->inject($this->viewHelper, 'viewHelperVariableContainer', $viewHelperVariableContainer);
$templateVariableContainer = new TemplateVariableContainer(array());
$this->inject($this->viewHelper, 'templateVariableContainer', $templateVariableContainer);
$this->viewHelper->setRenderChildrenClosure(function () use($templateVariableContainer) {
$linkedNode = $templateVariableContainer->get('linkedNode');
return $linkedNode !== null ? $linkedNode->getLabel() : '';
});
$this->viewHelper->initialize();
}
/**
* Validate that test routes are loaded
*/
public function setUp()
{
parent::setUp();
$foundRoute = false;
/** @var $route Route */
foreach ($this->router->getRoutes() as $route) {
if ($route->getName() === 'Flow :: Functional Test: HTTP - FooController') {
$foundRoute = true;
break;
}
}
if (!$foundRoute) {
$this->markTestSkipped('In this distribution the Flow routes are not included into the global configuration.');
return;
}
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$workspaceRepository = $this->objectManager->get(\Neos\ContentRepository\Domain\Repository\WorkspaceRepository::class);
$workspaceRepository->add(new Workspace('live'));
$this->persistenceManager->persistAll();
$this->contextFactory = $this->objectManager->get(\Neos\ContentRepository\Domain\Service\ContextFactoryInterface::class);
$this->context = $this->contextFactory->create(array('workspaceName' => 'live'));
$siteImportService = $this->objectManager->get(\Neos\Neos\Domain\Service\SiteImportService::class);
$siteImportService->importFromFile(__DIR__ . '/Fixtures/SortableNodes.xml', $this->context);
$this->persistenceManager->persistAll();
$this->persistenceManager->clearState();
$this->inject($this->contextFactory, 'contextInstances', array());
// The context is not important here, just a quick way to get a (live) workspace
// $context = $this->contextFactory->create();
$this->nodeDataRepository = $this->objectManager->get(\Neos\ContentRepository\Domain\Repository\NodeDataRepository::class);
}
public function setUp()
{
parent::setUp();
$this->mockQueueManager = $this->getMockBuilder(QueueManager::class)->disableOriginalConstructor()->getMock();
$this->testQueue = new TestQueue('TestQueue');
$this->mockQueueManager->expects($this->any())->method('getQueue')->with('TestQueue')->will($this->returnValue($this->testQueue));
$this->mockQueueManager->expects($this->any())->method('getQueueSettings')->with('TestQueue')->will($this->returnCallback(function () {
return $this->queueSettings;
}));
$this->jobManager = new JobManager();
$this->inject($this->jobManager, 'queueManager', $this->mockQueueManager);
self::$bootstrap->getSignalSlotDispatcher()->connect(JobManager::class, 'messageSubmitted', $this, 'logSignal');
self::$bootstrap->getSignalSlotDispatcher()->connect(JobManager::class, 'messageTimeout', $this, 'logSignal');
self::$bootstrap->getSignalSlotDispatcher()->connect(JobManager::class, 'messageReserved', $this, 'logSignal');
self::$bootstrap->getSignalSlotDispatcher()->connect(JobManager::class, 'messageFinished', $this, 'logSignal');
self::$bootstrap->getSignalSlotDispatcher()->connect(JobManager::class, 'messageReleased', $this, 'logSignal');
self::$bootstrap->getSignalSlotDispatcher()->connect(JobManager::class, 'messageFailed', $this, 'logSignal');
}
/**
* @return void
*/
public function setUp()
{
parent::setUp();
$this->nodeDataRepository = new NodeDataRepository();
if ($this->liveWorkspace === null) {
$this->liveWorkspace = new Workspace('live');
$this->objectManager->get(WorkspaceRepository::class);
$this->workspaceRepository = $this->objectManager->get(WorkspaceRepository::class);
$this->workspaceRepository->add($this->liveWorkspace);
$this->workspaceRepository->add(new Workspace('user-admin', $this->liveWorkspace));
$this->workspaceRepository->add(new Workspace('live2', $this->liveWorkspace));
$this->workspaceRepository->add(new Workspace('test', $this->liveWorkspace));
$this->persistenceManager->persistAll();
}
$this->contextFactory = $this->objectManager->get(ContextFactoryInterface::class);
$this->context = $this->contextFactory->create(['workspaceName' => 'live']);
$this->nodeTypeManager = $this->objectManager->get(NodeTypeManager::class);
$this->contentDimensionRepository = $this->objectManager->get(ContentDimensionRepository::class);
}
