/** * @param bool $hasLogger * @dataProvider debugDataProvider */ public function testDebug($hasLogger) { $doctrineHelper = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock(); $definitionName = 'test_definition'; $definition = new ProcessDefinition(); $definition->setName($definitionName); $triggerEvent = ProcessTrigger::EVENT_UPDATE; $trigger = new ProcessTrigger(); $trigger->setEvent($triggerEvent)->setDefinition($definition); $entity = new \stdClass(); $entityId = 1; $data = new ProcessData(array('data' => $entity)); $message = 'Test debug message'; $context = array('definition' => $definitionName, 'event' => $triggerEvent, 'entityId' => $entityId); if ($hasLogger) { $doctrineHelper->expects($this->once())->method('getSingleEntityIdentifier')->with($entity, false)->will($this->returnValue($entityId)); $logger = $this->getMock('Psr\\Log\\LoggerInterface'); $logger->expects($this->once())->method('debug')->with($message, $context); } else { $doctrineHelper->expects($this->never())->method('getSingleEntityIdentifier'); $logger = null; } $processLogger = new ProcessLogger($doctrineHelper, $logger); $processLogger->debug($message, $trigger, $data); }
public function testPreUpdate() { $this->assertNull($this->entity->getUpdatedAt()); $this->entity->preUpdate(); $this->assertInstanceOf('\\DateTime', $this->entity->getUpdatedAt()); $this->assertEquals('UTC', $this->entity->getUpdatedAt()->getTimezone()->getName()); }
public function testPostFlush() { $serializedData = 'serializedData'; $processDefinition = new ProcessDefinition(); $processDefinition->setRelatedEntity(self::TEST_CLASS); $processTrigger = new ProcessTrigger(); $processTrigger->setDefinition($processDefinition); $processData = new ProcessData(); $processData->set('test', 'value'); $processJob = new ProcessJob(); $processJob->setProcessTrigger($processTrigger)->setData($processData); $unitOfWork = $this->getMockBuilder('Doctrine\\ORM\\UnitOfWork')->disableOriginalConstructor()->getMock(); $unitOfWork->expects($this->at(0))->method('getScheduledEntityInsertions')->will($this->returnValue(array($processJob))); $unitOfWork->expects($this->at(1))->method('getScheduledEntityUpdates')->will($this->returnValue(array($processJob))); $entityId = 1; $entityHash = ProcessJob::generateEntityHash(self::TEST_CLASS, $entityId); $this->serializer->expects($this->exactly(2))->method('serialize')->with($processJob->getData(), 'json', array('processJob' => $processJob))->will($this->returnCallback(function () use($processJob, $entityId, $serializedData) { $processJob->setEntityId($entityId); return $serializedData; })); $entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $entityManager->expects($this->any())->method('getUnitOfWork')->will($this->returnValue($unitOfWork)); $entityManager->expects($this->once())->method('flush'); $this->listener->onFlush(new OnFlushEventArgs($entityManager)); $this->listener->postFlush(new PostFlushEventArgs($entityManager)); $this->assertEquals($serializedData, $processJob->getSerializedData()); $this->assertEquals($entityId, $processJob->getEntityId()); $this->assertEquals($entityHash, $processJob->getEntityHash()); $this->assertFalse($processJob->getData()->isModified()); }
/** * {@inheritDoc} */ public function load(ObjectManager $manager) { $entityManager = $this->container->get('doctrine')->getManager(); // first definition $firstDefinition = new ProcessDefinition(); $firstDefinition->setName(self::FIRST_DEFINITION)->setLabel(self::FIRST_DEFINITION)->setRelatedEntity('Test\\Entity')->setExecutionOrder(10); $updateTrigger = new ProcessTrigger(); $updateTrigger->setDefinition($firstDefinition)->setEvent(ProcessTrigger::EVENT_UPDATE)->setField(self::UPDATE_TRIGGER_FIELD); $entityManager->persist($firstDefinition); $entityManager->persist($updateTrigger); // second definition $secondDefinition = new ProcessDefinition(); $secondDefinition->setName(self::SECOND_DEFINITION)->setLabel(self::SECOND_DEFINITION)->setRelatedEntity('Test\\Entity')->setExecutionOrder(20); $createTrigger = new ProcessTrigger(); $createTrigger->setDefinition($secondDefinition)->setEvent(ProcessTrigger::EVENT_CREATE); $deleteTrigger = new ProcessTrigger(); $deleteTrigger->setDefinition($secondDefinition)->setEvent(ProcessTrigger::EVENT_DELETE); $entityManager->persist($secondDefinition); $entityManager->persist($createTrigger); $entityManager->persist($deleteTrigger); // disabled definition $disabledDefinition = new ProcessDefinition(); $disabledDefinition->setName(self::DISABLED_DEFINITION)->setLabel(self::DISABLED_DEFINITION)->setRelatedEntity('Test\\Entity')->setExecutionOrder(30)->setEnabled(false); $createTrigger = new ProcessTrigger(); $createTrigger->setDefinition($disabledDefinition)->setEvent(ProcessTrigger::EVENT_CREATE); $entityManager->persist($disabledDefinition); $entityManager->persist($createTrigger); $entityManager->flush(); }
protected function getAction() { if (!$this->action) { $this->action = $this->actionAssembler->assemble($this->processDefinition->getActionsConfiguration()); } return $this->action; }
protected function createNewEnabledProcessDefinition() { $testEntity = new ProcessDefinition(); $testEntity->setName('test_' . uniqid())->setLabel('Test ' . uniqid())->setEnabled(true)->setRelatedEntity('My/Test/Entity'); $this->entityManager->persist($testEntity); $this->entityManager->flush($testEntity); return $testEntity; }
/** * Deactivate process * * Returns * - HTTP_OK (204) * * @Rest\Get( * "/api/rest/{version}/process/deactivate/{processDefinition}", * requirements={"version"="latest|v1"}, * defaults={"version"="latest", "_format"="json"} * ) * @ApiDoc(description="Deactivate process", resource=true) * @AclAncestor("oro_process_definition_update") * * @param ProcessDefinition $processDefinition * @return Response */ public function deactivateAction(ProcessDefinition $processDefinition) { $processDefinition->setEnabled(false); $entityManager = $this->getManager(); $entityManager->persist($processDefinition); $entityManager->flush(); return $this->handleView($this->view(array('message' => $this->get('translator')->trans('oro.workflow.notification.process.deactivated'), 'successful' => true), Codes::HTTP_OK)); }
/** * @return bool|AbstractCondition */ protected function getPreCondition() { if ($this->preCondition === null) { $this->preCondition = false; $conditionConfiguration = $this->processDefinition->getPreConditionsConfiguration(); if ($conditionConfiguration) { $this->preCondition = $this->conditionFactory->create(ConfigurableCondition::ALIAS, $conditionConfiguration); } } return $this->preCondition; }
/** * @param $name * @param array $configuration * @return ProcessDefinition */ public function buildProcessDefinition($name, array $configuration) { $this->assertConfigurationOptions($configuration, array('label', 'entity')); $enabled = $this->getConfigurationOption($configuration, 'enabled', true); $order = $this->getConfigurationOption($configuration, 'order', 0); $excludeDefinitions = $this->getConfigurationOption($configuration, 'exclude_definitions', array()); $actionsConfiguration = $this->getConfigurationOption($configuration, 'actions_configuration', array()); $definition = new ProcessDefinition(); $definition->setName($name)->setLabel($configuration['label'])->setRelatedEntity($configuration['entity'])->setEnabled($enabled)->setExecutionOrder($order)->setExcludeDefinitions($excludeDefinitions)->setActionsConfiguration($actionsConfiguration); return $definition; }
public function testExecutePreConditionsAreNotMet() { $context = []; $conditionConfiguration = ['test' => []]; $condition = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Model\\Condition\\Configurable')->disableOriginalConstructor()->getMock(); $condition->expects($this->any())->method('evaluate')->with($context)->will($this->returnValue(false)); $this->processDefinition->expects($this->once())->method('getPreConditionsConfiguration')->will($this->returnValue($conditionConfiguration)); $this->conditionFactory->expects($this->once())->method('create')->with(ConfigurableCondition::ALIAS, $conditionConfiguration)->will($this->returnValue($condition)); $this->processDefinition->expects($this->never())->method('getActionsConfiguration'); $this->actionAssembler->expects($this->never())->method('assemble'); $this->process->execute($context); }
/** * {@inheritDoc} */ public function load(ObjectManager $manager) { foreach ($this->definitions as $name => $config) { $definition = new ProcessDefinition(); $definition->setName($name)->setLabel($name)->setRelatedEntity($config['related_entity'])->setExecutionOrder($config['execution_order'])->setEnabled($config['enabled']); $this->definitions[$name] = $definition; $manager->persist($definition); } foreach ($this->triggers as $key => $config) { $trigger = new ProcessTrigger(); $trigger->setDefinition($this->definitions[$config['definition']])->setEvent($config['event'])->setField($config['field'])->setCron($config['cron']); $manager->persist($trigger); $this->addReference($key, $trigger); } $manager->flush(); }
public function testSetGetEntityIdAndHash() { $entityClass = 'Test\\Entity'; $entityId = 12; $definition = new ProcessDefinition(); $definition->setRelatedEntity($entityClass); $trigger = new ProcessTrigger(); $trigger->setDefinition($definition); $this->entity->setProcessTrigger($trigger); $this->assertNull($this->entity->getEntityId()); $this->assertNull($this->entity->getEntityHash()); $this->entity->setEntityId($entityId); $this->assertEquals($entityId, $this->entity->getEntityId()); $this->assertEquals(ProcessJob::generateEntityHash($entityClass, $entityId), $this->entity->getEntityHash()); $this->entity->setEntityId(null); $this->assertNull($this->entity->getEntityId()); $this->assertNull($this->entity->getEntityHash()); }
/** * @param array $configuration * @param array $expected * @dataProvider buildProcessTriggersDataProvider */ public function testBuildProcessTriggers(array $configuration, array $expected) { $testDefinition = new ProcessDefinition(); $testDefinition->setName(self::TEST_DEFINITION_NAME); $definitionsByName = array(self::TEST_DEFINITION_NAME => $testDefinition); $triggers = $this->builder->buildProcessTriggers($configuration, $definitionsByName); $expectedTriggers = array(); $this->assertSameSize($expected, $configuration); foreach ($configuration as $definitionName => $configurationData) { $this->assertArrayHasKey($definitionName, $expected); $expectedData = $expected[$definitionName]; $this->assertSameSize($expectedData, $configurationData); foreach ($expectedData as $expectedDataSet) { $expectedTriggers[] = $expectedDataSet; } } $this->assertSameSize($expectedTriggers, $triggers); while ($expectedTrigger = array_shift($expectedTriggers)) { /** @var ProcessTrigger $trigger */ $trigger = array_shift($triggers); $this->assertInstanceOf('Oro\\Bundle\\WorkflowBundle\\Entity\\ProcessTrigger', $trigger); $this->assertNotEmpty($trigger->getDefinition()); $this->assertInstanceOf('Oro\\Bundle\\WorkflowBundle\\Entity\\ProcessDefinition', $trigger->getDefinition()); $definitionName = $trigger->getDefinition()->getName(); $this->assertArrayHasKey($definitionName, $definitionsByName); $this->assertProcessTrigger($expectedTrigger, $definitionsByName[$definitionName], $trigger); } }
/** * @param array $data */ protected function prepareRegistryForBuild(array $data) { // generate triggers $triggers = array(); foreach ($data as $entityClass => $events) { $definition = new ProcessDefinition(); $definition->setRelatedEntity($entityClass); foreach ($events as $event) { $trigger = new ProcessTrigger(); $trigger->setDefinition($definition)->setEvent($event); $triggers[] = $trigger; } } // set mocks $triggerClass = 'OroWorkflowBundle:ProcessTrigger'; $repository = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Entity\\Repository\\ProcessTriggerRepository')->disableOriginalConstructor()->getMock(); $repository->expects($this->any())->method('findAllWithDefinitions')->will($this->returnValue($triggers)); $entityManager = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $entityManager->expects($this->any())->method('getRepository')->with($triggerClass)->will($this->returnValue($repository)); $this->registry->expects($this->any())->method('getManagerForClass')->with($triggerClass)->will($this->returnValue($entityManager)); }
/** * @param ProcessDefinition $definition * @return ProcessDefinition */ public function import(ProcessDefinition $definition) { // enabled flag should not be imported $this->setName($definition->getName())->setLabel($definition->getLabel())->setRelatedEntity($definition->getRelatedEntity())->setExecutionOrder($definition->getExecutionOrder())->setActionsConfiguration($definition->getActionsConfiguration())->setExcludeDefinitions($definition->getExcludeDefinitions()); return $this; }
/** * @param array $ids * @return ProcessJob[] */ protected function populateProcessJobs(array $ids) { $result = []; foreach ($ids as $id) { $process = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Entity\\ProcessJob')->disableOriginalConstructor()->getMock(); $process->expects($this->any())->method('getId')->will($this->returnValue($id)); $definition = new ProcessDefinition(); $definition->setName('name'); $definition->setLabel('label'); $processTrigger = new ProcessTrigger(); $processTrigger->setDefinition($definition); $process->expects($this->any())->method('getProcessTrigger')->will($this->returnValue($processTrigger)); $result[] = $process; } return $result; }
/** * @param int $id * @return ProcessTrigger */ protected function createProcessTrigger($id) { $definition = new ProcessDefinition(); $definition->setName('name')->setLabel('label')->setRelatedEntity('\\StdClass'); $processTrigger = new ProcessTrigger(); $processTrigger->setDefinition($definition); $class = new \ReflectionClass($processTrigger); $prop = $class->getProperty('id'); $prop->setAccessible(true); $prop->setValue($processTrigger, $id); return $processTrigger; }
/** * @param string $event * @return ProcessJob */ protected function createProcessJob($event) { $definition = new ProcessDefinition(); $definition->setRelatedEntity('Test\\Entity'); $trigger = new ProcessTrigger(); $trigger->setDefinition($definition)->setEvent($event); $job = new ProcessJob(); $job->setProcessTrigger($trigger); return $job; }
/** * @param array $config * @return ProcessTrigger */ protected function getCustomQueuedTrigger(array $config) { $definition = new ProcessDefinition(); $definition->setName('test-' . uniqid())->setRelatedEntity(self::ENTITY); $entityTrigger = new ProcessTrigger(); $entityTrigger->setDefinition($definition)->setEvent($config['event'])->setQueued(true)->setPriority($config['priority'])->setTimeShift($config['timeShift']); return $entityTrigger; }