public function testFailureExceptions()
{
$obj = new JobResult();
$obj->addFailureException('Error 1');
$obj->addFailureException('Error 2');
$this->assertEquals(array('Error 1', 'Error 2'), $obj->getFailureExceptions());
}
/**
* @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 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());
}
/**
* @param JobResult $jobResult
* @return array
*/
protected function getErrors(JobResult $jobResult)
{
$context = $jobResult->getContext();
$contextErrors = [];
if ($context) {
$contextErrors = $context->getErrors();
}
return array_slice(array_merge($jobResult->getFailureExceptions(), $contextErrors), 0, 100);
}
/**
* @dataProvider eventDataProvider
*
* @param string $jobName
* @param string $exceptionMessage
* @param string $expectedMessage
*/
public function testProcess($jobName, $exceptionMessage, $expectedMessage)
{
$jobResult = new JobResult();
$jobResult->addFailureException($exceptionMessage);
$event = new SyncEvent($jobName, [], $jobResult);
$this->listener->process($event);
$exceptions = $jobResult->getFailureExceptions();
$this->assertEquals($expectedMessage, reset($exceptions));
}
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 JobResult $jobResult
* @return array
*/
protected function getValidationCounts(JobResult $jobResult)
{
$context = $jobResult->getContext();
$counts = [];
$counts['errors'] = count($jobResult->getFailureExceptions());
if ($context) {
$counts['process'] = 0;
$counts['read'] = $context->getReadCount();
$counts['process'] += $counts['add'] = $context->getAddCount();
$counts['process'] += $counts['replace'] = $context->getReplaceCount();
$counts['process'] += $counts['update'] = $context->getUpdateCount();
$counts['process'] += $counts['delete'] = $context->getDeleteCount();
$counts['error_entries'] = $context->getErrorEntriesCount();
$counts['errors'] += count($context->getErrors());
return $counts;
}
return $counts;
}
/**
* @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 JobResult $jobResult
*/
protected function assertDatabaseContent(JobResult $jobResult)
{
$fixtures = new \RecursiveDirectoryIterator(__DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'Stub' . DIRECTORY_SEPARATOR . 'fixtures', \RecursiveDirectoryIterator::SKIP_DOTS);
$campaignRepo = $this->getContainer()->get('doctrine')->getRepository('OroCRMMailChimpBundle:Campaign');
$repository = $this->getContainer()->get('doctrine')->getRepository('OroCRMMailChimpBundle:MemberActivity');
$addCount = 0;
$fullCount = 0;
foreach ($fixtures as $file) {
$data = Yaml::parse($file->getPathName());
$addCount += $data['addCount'];
$fullCount += $data['fullCount'];
foreach ($data['database'] as $criteria) {
$campaign = $campaignRepo->findOneBy(['originId' => $criteria['campaign']]);
$criteria['campaign'] = $campaign->getId();
if (!empty($criteria['activityTime'])) {
$criteria['activityTime'] = new \DateTime($criteria['activityTime'], new \DateTimeZone('UTC'));
}
$result = $repository->findBy($criteria);
$this->assertCount(1, $result, $file->getFileName());
}
}
$this->assertEquals($addCount, $jobResult->getContext()->getAddCount());
$this->assertCount($fullCount, $repository->findAll());
}
/**
* @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 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;
}
/**
* Set data to JobResult
* TODO: Find a way to work with multiple amount of job and step executions
* TODO https://magecore.atlassian.net/browse/BAP-2600
*
* @param JobResult $jobResult
* @param JobInstance $jobInstance
*/
protected function setJobResultData(JobResult $jobResult, JobInstance $jobInstance)
{
$jobResult->setJobId($jobInstance->getId());
$jobResult->setJobCode($jobInstance->getCode());
/** @var JobExecution $jobExecution */
$jobExecution = $jobInstance->getJobExecutions()->first();
if ($jobExecution) {
$stepExecutions = $jobExecution->getStepExecutions();
/** @var StepExecution $firstStepExecution */
$firstStepExecution = $stepExecutions->first();
if ($firstStepExecution) {
$context = $this->contextRegistry->getByStepExecution($firstStepExecution);
if ($stepExecutions->count() > 1) {
/** @var StepExecution $stepExecution */
foreach ($stepExecutions->slice(1) as $stepExecution) {
ContextHelper::mergeContextCounters($context, $this->contextRegistry->getByStepExecution($stepExecution));
}
}
$jobResult->setContext($context);
}
}
}
