/**
* @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;
}
