/**
* @param JobExecution $jobExecution
* @param JobInstance $jobInstance
* @return JobResult
*/
protected function doJob(JobInstance $jobInstance, JobExecution $jobExecution)
{
$jobResult = new JobResult();
$jobResult->setSuccessful(false);
try {
$job = $this->batchJobRegistry->getJob($jobInstance);
if (!$job) {
throw new RuntimeException(sprintf('Can\'t find job "%s"', $jobInstance->getAlias()));
}
$job->execute($jobExecution);
$failureExceptions = $this->collectFailureExceptions($jobExecution);
if ($jobExecution->getStatus()->getValue() == BatchStatus::COMPLETED && !$failureExceptions) {
$jobResult->setSuccessful(true);
} else {
foreach ($failureExceptions as $failureException) {
$jobResult->addFailureException($failureException);
}
}
// trigger save of JobExecution and JobInstance
$this->batchJobRepository->getJobManager()->flush();
$this->batchJobRepository->getJobManager()->clear();
} catch (\Exception $exception) {
$jobExecution->addFailureException($exception);
$jobResult->addFailureException($exception->getMessage());
$this->saveFailedJobExecution($jobExecution);
}
return $jobResult;
}
/**
* @param string $jobType
* @param string $jobName
* @param array $configuration
* @return JobResult
*/
public function executeJob($jobType, $jobName, array $configuration = array())
{
// create and persist job instance and job execution
$jobInstance = new JobInstance(self::CONNECTOR_NAME, $jobType, $jobName);
$jobInstance->setCode($this->generateJobCode($jobName));
$jobInstance->setLabel(sprintf('%s.%s', $jobType, $jobName));
$jobInstance->setRawConfiguration($configuration);
$jobExecution = new JobExecution();
$jobExecution->setJobInstance($jobInstance);
$jobResult = new JobResult();
$jobResult->setSuccessful(false);
$this->entityManager->beginTransaction();
try {
$job = $this->jobRegistry->getJob($jobInstance);
if (!$job) {
throw new RuntimeException(sprintf('Can\'t find job "%s"', $jobName));
}
// TODO: Refactor whole logic of job execution to perform actions in transactions
$job->execute($jobExecution);
$failureExceptions = $this->collectFailureExceptions($jobExecution);
if ($jobExecution->getStatus()->getValue() == BatchStatus::COMPLETED && !$failureExceptions) {
$this->entityManager->commit();
$jobResult->setSuccessful(true);
} else {
$this->entityManager->rollback();
foreach ($failureExceptions as $failureException) {
$jobResult->addFailureException($failureException);
}
}
} catch (\Exception $exception) {
$this->entityManager->rollback();
$jobExecution->addFailureException($exception);
$jobResult->addFailureException($exception->getMessage());
}
// save job instance
$this->entityManager->persist($jobInstance);
$this->entityManager->flush($jobInstance);
// set data to JobResult
$jobResult->setJobId($jobInstance->getId());
$jobResult->setJobCode($jobInstance->getCode());
/** @var JobExecution $jobExecution */
$jobExecution = $jobInstance->getJobExecutions()->first();
if ($jobExecution) {
$stepExecution = $jobExecution->getStepExecutions()->first();
if ($stepExecution) {
$context = $this->contextRegistry->getByStepExecution($stepExecution);
$jobResult->setContext($context);
}
}
return $jobResult;
}
/**
* @param array $contextSharedKeys
* @param array $context
* @param array $job
* @param bool $isJobSuccess
* @param int $jobExecutions
* @param array $expectedContext
*
* @dataProvider executeDataProvider
*/
public function testExecute(array $contextSharedKeys, array $context, array $job, $isJobSuccess = true, $jobExecutions = 0, $expectedContext = [])
{
if ($job) {
list($jobType, $jobName) = $job;
$this->executor->addPostProcessingJob($jobType, $jobName);
}
$this->executor->setContextSharedKeys($contextSharedKeys);
/** @var \PHPUnit_Framework_MockObject_MockObject|StepExecution $stepExecution */
$stepExecution = $this->getMockBuilder('Akeneo\\Bundle\\BatchBundle\\Entity\\StepExecution')->disableOriginalConstructor()->getMock();
$executionContext = new ExecutionContext();
foreach ($context as $key => $value) {
$executionContext->put($key, $value);
}
$jobExecution = $this->getMock('Akeneo\\Bundle\\BatchBundle\\Entity\\JobExecution');
$jobInstance = $this->getMock('Akeneo\\Bundle\\BatchBundle\\Entity\\JobInstance');
$jobExecution->expects($this->any())->method('getJobInstance')->will($this->returnValue($jobInstance));
$jobExecution->expects($this->any())->method('getExecutionContext')->will($this->returnValue($executionContext));
$stepExecution->expects($this->any())->method('getJobExecution')->will($this->returnValue($jobExecution));
$this->executor->setStepExecution($stepExecution);
$jobResult = new JobResult();
$jobResult->setSuccessful($isJobSuccess);
if (!$isJobSuccess) {
$this->setExpectedException('Oro\\Bundle\\ImportExportBundle\\Exception\\RuntimeException');
}
$this->jobExecutor->expects($this->exactly($jobExecutions))->method('executeJob')->willReturn($jobResult);
$this->processor->expects($this->any())->method('process')->willReturnArgument(0);
$this->reader->expects($this->atLeastOnce())->method('read')->willReturnOnConsecutiveCalls(new \stdClass(), new \stdClass(), new \stdClass(), null);
$this->executor->execute();
$this->assertEquals($expectedContext, $executionContext->getKeys());
}
protected function setUp()
{
$this->initClient(['debug' => false], $this->generateBasicAuthHeader(), true);
$this->loadFixtures(['OroCRM\\Bundle\\MagentoBundle\\Tests\\Functional\\Fixture\\LoadNewsletterSubscriberData'], true);
$this->subscriber = $this->getReference('newsletter_subscriber');
$this->baseJobExecutor = $this->getContainer()->get('oro_importexport.job_executor');
$jobExecutor = $this->getMockBuilder('Oro\\Bundle\\ImportExportBundle\\Job\\JobExecutor')->disableOriginalConstructor()->getMock();
$jobResult = new JobResult();
$jobResult->setSuccessful(true);
$jobExecutor->expects($this->any())->method('executeJob')->willReturn($jobResult);
$this->getContainer()->set('oro_importexport.job_executor', $jobExecutor);
}
/**
* @dataProvider testProcessDataProvider
*/
public function testProcess($data, $expected)
{
$this->integration->expects($this->once())->method('getConnectors')->willReturn($data['integrationConnectors']);
$this->integration->expects($this->any())->method('getId')->willReturn($data['channel']);
$this->integration->expects($this->atLeastOnce())->method('getType')->willReturn($data['integrationType']);
$this->integration->expects($this->once())->method('isEnabled')->willReturn(true);
$this->registry->expects($this->any())->method('getConnectorType')->willReturnMap($data['realConnectorsMap']);
$this->processorRegistry->expects($this->any())->method('getProcessorAliasesByEntity')->willReturn([]);
$jobResult = new JobResult();
$jobResult->setContext(new TestContext());
$jobResult->setSuccessful(true);
$mocker = $this->jobExecutor->expects($this->exactly(count($expected)))->method('executeJob');
call_user_func_array([$mocker, 'withConsecutive'], $expected);
$mocker->willReturn($jobResult);
$processor = $this->getSyncProcessor();
$processor->process($this->integration, $data['connector'], $data['parameters']);
}
public function testOneIntegrationConnectorProcess()
{
$connector = 'testConnector';
$this->integration->expects($this->never())->method('getConnectors');
$this->integration->expects($this->once())->method('getId')->will($this->returnValue('testChannel'));
$expectedAlias = 'test_alias';
$this->processorRegistry->expects($this->once())->method('getProcessorAliasesByEntity')->with(ProcessorRegistry::TYPE_EXPORT)->will($this->returnValue(array($expectedAlias)));
$realConnector = new TestConnector();
$this->registry->expects($this->once())->method('getConnectorType')->will($this->returnValue($realConnector));
$this->integration->expects($this->once())->method('getEnabled')->will($this->returnValue(true));
$jobResult = new JobResult();
$jobResult->setContext(new TestContext());
$jobResult->setSuccessful(true);
$this->jobExecutor->expects($this->once())->method('executeJob')->with('export', 'tstJobName', ['export' => ['entityName' => 'testEntity', 'channel' => 'testChannel', 'processorAlias' => $expectedAlias, 'testParameter' => 'testValue']])->will($this->returnValue($jobResult));
$processor = $this->getReverseSyncProcessor();
$processor->process($this->integration, $connector, ['testParameter' => 'testValue']);
}
public function testOneChannelConnectorProcess()
{
$connector = 'testConnector';
$connectors = [$connector];
$this->integration->expects($this->once())->method('getConnectors')->will($this->returnValue($connectors));
$this->integration->expects($this->once())->method('getId')->will($this->returnValue('testChannel'));
$this->integration->expects($this->atLeastOnce())->method('getType')->will($this->returnValue('testChannelType'));
$this->integration->expects($this->once())->method('isEnabled')->will($this->returnValue(true));
$realConnector = new TestConnector();
$this->registry->expects($this->once())->method('getConnectorType')->will($this->returnValue($realConnector));
$this->processorRegistry->expects($this->once())->method('getProcessorAliasesByEntity')->will($this->returnValue([]));
$jobResult = new JobResult();
$jobResult->setContext(new TestContext());
$jobResult->setSuccessful(true);
$this->jobExecutor->expects($this->once())->method('executeJob')->with('import', 'test job', ['import' => ['processorAlias' => false, 'entityName' => 'testEntity', 'channel' => 'testChannel', 'channelType' => 'testChannelType', 'testParameter' => 'testValue']])->will($this->returnValue($jobResult));
$processor = $this->getSyncProcessor();
$processor->process($this->integration, $connector, ['testParameter' => 'testValue']);
}
/**
* @param array $expectedConfig
*/
public function assertExecuteJob(array $expectedConfig = null)
{
$jobResult = new JobResult();
$jobResult->setContext(new TestContext());
$jobResult->setSuccessful(true);
if ($expectedConfig) {
$this->jobExecutor->expects($this->any())->method('executeJob')->with($this->equalTo(ProcessorRegistry::TYPE_IMPORT), $this->equalTo('test job'), $this->callback(function (array $config) use($expectedConfig) {
// dictionary
if (!array_key_exists('initialSyncInterval', $config)) {
return true;
}
$this->assertArrayHasKey(ProcessorRegistry::TYPE_IMPORT, $config);
$diff = array_diff_key($config[ProcessorRegistry::TYPE_IMPORT], $expectedConfig);
if (!$diff) {
$this->assertEquals($expectedConfig, $config[ProcessorRegistry::TYPE_IMPORT]);
return true;
}
$intersect = array_diff_key($config[ProcessorRegistry::TYPE_IMPORT], $diff);
$this->assertEquals($expectedConfig, $intersect);
if ($diff) {
$this->assertArrayHasKey('initialSyncedTo', $diff);
/** @var \DateTime $date */
$date = $diff['initialSyncedTo'];
$interval = $date->diff(new \DateTime('now', new \DateTimeZone('UTC')));
$this->assertEmpty($interval->m);
}
return true;
}))->will($this->returnValue($jobResult));
} else {
$this->jobExecutor->expects($this->any())->method('executeJob')->with(ProcessorRegistry::TYPE_IMPORT, 'test job', $this->isType('array'))->will($this->returnValue($jobResult));
}
}
/**
* @param JobExecution $jobExecution
* @param JobInstance $jobInstance
* @return JobResult
*/
protected function doJob(JobInstance $jobInstance, JobExecution $jobExecution)
{
$jobResult = new JobResult();
$jobResult->setSuccessful(false);
$this->entityManager->beginTransaction();
try {
$job = $this->batchJobRegistry->getJob($jobInstance);
if (!$job) {
throw new RuntimeException(sprintf('Can\'t find job "%s"', $jobInstance->getAlias()));
}
$job->execute($jobExecution);
$failureExceptions = $this->collectFailureExceptions($jobExecution);
if ($jobExecution->getStatus()->getValue() == BatchStatus::COMPLETED && !$failureExceptions) {
$this->entityManager->commit();
$jobResult->setSuccessful(true);
} else {
$this->entityManager->rollback();
foreach ($failureExceptions as $failureException) {
$jobResult->addFailureException($failureException);
}
}
} catch (\Exception $exception) {
$this->entityManager->rollback();
$jobExecution->addFailureException($exception);
$jobResult->addFailureException($exception->getMessage());
}
return $jobResult;
}
/**
* @param JobExecution $jobExecution
* @param JobResult $jobResult
*
* @return bool
*/
protected function handleJobResult(JobExecution $jobExecution, JobResult $jobResult)
{
$failureExceptions = $this->collectFailureExceptions($jobExecution);
$isSuccessful = $jobExecution->getStatus()->getValue() === BatchStatus::COMPLETED && !$failureExceptions;
if ($isSuccessful) {
$jobResult->setSuccessful(true);
} elseif ($failureExceptions) {
foreach ($failureExceptions as $failureException) {
$jobResult->addFailureException($failureException);
}
}
return $isSuccessful;
}
