function it_normalizes_a_step_execution($translator, $presenter, $labelProvider, JobInstance $jobInstance, JobExecution $jobExecution, StepExecution $stepExecution, BatchStatus $status)
{
$jobExecution->getJobInstance()->willReturn($jobInstance);
$stepExecution->getJobExecution()->willReturn($jobExecution);
$stepExecution->getStepName()->willReturn('such_step');
$jobInstance->getJobName()->willReturn('wow_job');
$labelProvider->getStepLabel('wow_job', 'such_step')->willReturn('Export step');
$stepExecution->getSummary()->willReturn(['read' => 12, 'write' => 50]);
$translator->trans('job_execution.summary.read')->willReturn('Read');
$translator->trans('job_execution.summary.write')->willReturn('Write');
$stepExecution->getStatus()->willReturn($status);
$status->getValue()->willReturn(9);
$translator->trans('pim_import_export.batch_status.9')->willReturn('PENDING');
$date = new \DateTime();
$stepExecution->getStartTime()->willReturn($date);
$stepExecution->getEndTime()->willReturn(null);
$stepExecution->getWarnings()->willReturn(new ArrayCollection([new Warning($stepExecution->getWrappedObject(), 'warning_reason', ['foo' => 'bar'], ['a' => 'A', 'b' => 'B', 'c' => 'C'])]));
$translator->trans('a_warning')->willReturn('Reader');
$translator->trans(12)->willReturn(12);
$translator->trans(50)->willReturn(50);
$translator->trans('warning_reason', ['foo' => 'bar'])->willReturn('WARNING!');
$stepExecution->getFailureExceptions()->willReturn([['message' => 'a_failure', 'messageParameters' => ['foo' => 'bar']]]);
$translator->trans('a_failure', ['foo' => 'bar'])->willReturn('FAIL!');
$presenter->present($date, Argument::any())->willReturn('22-09-2014');
$presenter->present(null, Argument::any())->willReturn(null);
$this->normalize($stepExecution, 'any')->shouldReturn(['label' => 'Export step', 'status' => 'PENDING', 'summary' => ['Read' => 12, 'Write' => 50], 'startedAt' => '22-09-2014', 'endedAt' => null, 'warnings' => [['reason' => 'WARNING!', 'item' => ['a' => 'A', 'b' => 'B', 'c' => 'C']]], 'failures' => ['FAIL!']]);
}
/**
* @param array|string $data
*
* @return \Pim\Component\Catalog\Model\ProductInterface
*
* @Given /^a "([^"]*)" product$/
*/
public function createProduct($data)
{
if (is_string($data)) {
$data = ['sku' => $data];
} elseif (isset($data['enabled']) && in_array($data['enabled'], ['yes', 'no'])) {
$data['enabled'] = $data['enabled'] === 'yes';
}
foreach ($data as $key => $value) {
$data[$key] = $this->replacePlaceholders($value);
}
$converter = $this->getContainer()->get('pim_connector.array_converter.flat_to_standard.product');
$processor = $this->getContainer()->get('pim_connector.processor.denormalization.product');
$jobExecution = new JobExecution();
$provider = new ProductCsvImport(new SimpleCsvExport([]), []);
$params = $provider->getDefaultValues();
$params['enabledComparison'] = false;
$params['dateFormat'] = LocalizerInterface::DEFAULT_DATE_FORMAT;
$params['decimalSeparator'] = LocalizerInterface::DEFAULT_DECIMAL_SEPARATOR;
$jobParameters = new JobParameters($params);
$jobExecution->setJobParameters($jobParameters);
$stepExecution = new StepExecution('processor', $jobExecution);
$processor->setStepExecution($stepExecution);
$convertedData = $converter->convert($data);
$product = $processor->process($convertedData);
$this->getProductSaver()->save($product);
// reset the unique value set to allow to update product values
$uniqueValueSet = $this->getContainer()->get('pim_catalog.validator.unique_value_set');
$uniqueValueSet->reset();
$this->refresh($product);
return $product;
}
function it_throws_exception_when_serializer_is_not_a_normalizer(JobExecution $jobExecution, SerializerInterface $nonNormalizeSerializer, $exportExecution, $cleanExecution)
{
$this->setSerializer($nonNormalizeSerializer);
$jobExecution->getStepExecutions()->willReturn([$exportExecution, $cleanExecution]);
$jobExecution->getFailureExceptions()->willReturn([]);
$jobExecution->getLabel()->willReturn('My Job');
$this->shouldThrow(new \RuntimeException('Cannot normalize job execution of "My Job" because injected serializer is not a normalizer'))->duringNormalize($jobExecution, 'any');
}
/**
* {@inheritdoc}
*/
public function supports(JobExecution $jobExecution)
{
foreach ($jobExecution->getJobInstance()->getJob()->getSteps() as $step) {
if ($step instanceof ItemStep && $this->isUsableWriter($step->getWriter())) {
return true;
}
}
return false;
}
/**
* Retrieve the matching factory and create the notification
*
* @param JobExecution $jobExecution
*
* @throws \LogicException
*
* @return NotificationInterface
*/
protected function createNotification(JobExecution $jobExecution)
{
$type = $jobExecution->getJobInstance()->getType();
$factory = $this->factoryRegistry->get($type);
if (null === $factory) {
throw new \LogicException(sprintf('No notification factory found for the "%s" job type', $type));
}
$notification = $factory->create($jobExecution);
return $notification;
}
function it_returns_factory(JobExecution $jobExecution, JobInstance $jobInstance, BatchStatus $batchStatus)
{
$jobExecution->getJobInstance()->willReturn($jobInstance);
$jobExecution->getStatus()->willReturn($batchStatus);
$jobExecution->getId()->willReturn(1);
$batchStatus->isUnsuccessful()->willReturn(true);
$jobInstance->getType()->willReturn('import');
$jobInstance->getLabel()->willReturn('Import');
$this->create($jobExecution)->shouldReturnAnInstanceOf('Pim\\Bundle\\NotificationBundle\\Entity\\Notification');
}
/**
* Check if the job execution is supported
*
* @param JobExecution $jobExecution
*
* @return bool
*/
public function supports(JobExecution $jobExecution)
{
$job = $this->jobRegistry->get($jobExecution->getJobInstance()->getJobName());
foreach ($job->getSteps() as $step) {
if ($step instanceof ItemStep && $this->isReaderUsable($step->getReader())) {
return true;
}
}
return false;
}
/**
* @param JobExecution $jobExecution
*/
public function __construct(JobExecution $jobExecution)
{
$message = '';
foreach ($jobExecution->getFailureExceptions() as $exception) {
$message .= $this->getFailureExceptionMessage('JOB', $exception);
}
foreach ($jobExecution->getStepExecutions() as $stepExecution) {
$message .= $this->getStepExecutionMessages($stepExecution);
}
parent::__construct($message);
}
function it_returns_false_for_the_unsupported_job(ItemReaderInterface $reader, JobExecution $jobExecution, JobInstance $jobInstance, Job $job, ItemStep $step)
{
$jobExecution->getJobInstance()->willReturn($jobInstance);
$jobExecution->getId()->willReturn(12);
$jobInstance->getJob()->willReturn($job);
$jobInstance->getType()->willReturn('type');
$jobInstance->getAlias()->willReturn('alias');
$job->getSteps()->willReturn([$step]);
$step->getReader()->willReturn($reader);
$this->supports($jobExecution)->shouldReturn(false);
}
function it_returns_generated_archives(JobExecution $jobExecution, ArchiverInterface $archiver, ArchiverInterface $archiver2)
{
$jobExecution->isRunning()->willReturn(false);
$archiver->getName()->willReturn('output');
$archiver->getArchives($jobExecution)->willReturn(['a', 'b']);
$this->registerArchiver($archiver);
$archiver2->getName()->willReturn('input');
$archiver2->getArchives($jobExecution)->willReturn(['a', 'b']);
$this->registerArchiver($archiver2);
$this->getArchives($jobExecution)->shouldReturn(['output' => ['a', 'b'], 'input' => ['a', 'b']]);
}
/**
* Get the archives generated by the archivers
*
* @param JobExecution $jobExecution
*
* @return array
*/
public function getArchives(JobExecution $jobExecution)
{
$result = [];
if (!$jobExecution->isRunning()) {
foreach ($this->archivers as $archiver) {
if (count($archives = $archiver->getArchives($jobExecution)) > 0) {
$result[$archiver->getName()] = $archives;
}
}
}
return $result;
}
/**
* Constructor with mandatory properties.
*
* @param string $stepName the step to which this execution belongs
* @param JobExecution $jobExecution the current job execution
*/
public function __construct($stepName, JobExecution $jobExecution)
{
$this->stepName = $stepName;
$this->jobExecution = $jobExecution;
$jobExecution->addStepExecution($this);
$this->warnings = new ArrayCollection();
$this->executionContext = new ExecutionContext();
$this->setStatus(new BatchStatus(BatchStatus::STARTING));
$this->setExitStatus(new ExitStatus(ExitStatus::EXECUTING));
$this->failureExceptions = array();
$this->errors = array();
$this->startTime = new \DateTime();
}
/**
* {@inheritdoc}
*/
protected function setupWriter(JobExecution $jobExecution)
{
$fileKey = strtr($this->getRelativeArchivePath($jobExecution), ['%filename%' => 'invalid_items.xlsx']);
$this->filesystem->put($fileKey, '');
$writeParams = $this->defaultValuesProvider->getDefaultValues();
$writeParams['filePath'] = $this->filesystem->getAdapter()->getPathPrefix() . $fileKey;
$writeParams['withHeader'] = true;
$writeJobParameters = new JobParameters($writeParams);
$writeJobExecution = new JobExecution();
$writeJobExecution->setJobParameters($writeJobParameters);
$stepExecution = new StepExecution('processor', $writeJobExecution);
$this->writer->setStepExecution($stepExecution);
$this->writer->initialize();
}
function it_archives_unvalid_items(InvalidItemsCollector $collector, CsvWriter $writer, JobExecution $jobExecution, JobInstance $jobInstance, Filesystem $filesystem)
{
$collector->getInvalidItems()->willReturn(['items']);
$jobExecution->getId()->willReturn('id');
$jobExecution->getJobInstance()->willReturn($jobInstance);
$jobInstance->getType()->willReturn('type');
$jobInstance->getAlias()->willReturn('alias');
$filesystem->put('type/alias/id/invalid/invalid_items.csv', '')->shouldBeCalled();
$writer->setFilePath('/tmp/archivist/type/alias/id/invalid/invalid_items.csv')->shouldBeCalled();
$writer->initialize()->shouldBeCalled();
$writer->write(['items'])->shouldBeCalled();
$writer->flush()->shouldBeCalled();
$this->archive($jobExecution);
}
/**
* Return the job execution status
*
* @param JobExecution $jobExecution
*
* @return string
*/
protected function getJobStatus(JobExecution $jobExecution)
{
if ($jobExecution->getStatus()->isUnsuccessful()) {
$status = 'error';
} else {
$status = 'success';
foreach ($jobExecution->getStepExecutions() as $stepExecution) {
if ($stepExecution->getWarnings()->count() > 0) {
$status = 'warning';
break;
}
}
}
return $status;
}
function it_does_not_support_a_incompatible_job($jobRegistry, ItemWriterInterface $writer, JobExecution $jobExecution, JobInstance $jobInstance, Job $job, ItemStep $step)
{
$jobInstance->getJobName()->willReturn('my_job_name');
$jobRegistry->get('my_job_name')->willReturn($job);
$jobExecution->getJobInstance()->willReturn($jobInstance);
$jobExecution->getId()->willReturn(12);
$jobInstance->getType()->willReturn('type');
$job->getSteps()->willReturn([$step]);
$step->getWriter()->willReturn($writer);
$this->supports($jobExecution)->shouldReturn(false);
}
function it_creates_a_file_if_writer_is_correct(CsvWriter $writer, JobExecution $jobExecution, JobInstance $jobInstance, Job $job, ItemStep $step, $factory, $filesystem)
{
$file1 = tempnam(sys_get_temp_dir(), 'spec');
$file2 = tempnam(sys_get_temp_dir(), 'spec');
$jobExecution->getJobInstance()->willReturn($jobInstance);
$jobExecution->getId()->willReturn(12);
$jobInstance->getJob()->willReturn($job);
$jobInstance->getType()->willReturn('type');
$jobInstance->getAlias()->willReturn('alias');
$job->getSteps()->willReturn([$step]);
$step->getWriter()->willReturn($writer);
$writer->getWrittenFiles()->willReturn([$file1 => 'file1', $file2 => 'file2']);
$writer->getPath()->willReturn(sys_get_temp_dir());
$filesystem->has('type/alias/12/archive')->willReturn(false);
$filesystem->createDir('type/alias/12/archive')->shouldBeCalled();
$factory->createZip(Argument::any())->willReturn($filesystem);
$filesystem->put('file1', '')->shouldBeCalled();
$filesystem->put('file2', '')->shouldBeCalled();
$this->archive($jobExecution);
unlink($file1);
unlink($file2);
}
/**
* Mark a job execution as failed
* @param JobExecution $jobExecution
*/
public function markAsFailed(JobExecution $jobExecution)
{
$jobExecution->setStatus(new BatchStatus(BatchStatus::FAILED));
$jobExecution->setExitStatus(new ExitStatus(ExitStatus::FAILED));
$jobExecution->setEndTime(new \DateTime('now'));
$jobExecution->addFailureException(new \Exception('An exception occured during the job execution'));
$this->entityManager->persist($jobExecution);
$this->entityManager->flush();
}
function let(NotificationManager $manager, JobExecutionEvent $event, JobExecution $jobExecution, StepExecution $stepExecution, ArrayCollection $warnings, JobInstance $jobInstance, UserInterface $user, BatchStatus $status)
{
$this->beConstructedWith($manager);
$jobExecution->getUser()->willReturn($user);
$jobExecution->getStepExecutions()->willReturn([$stepExecution]);
$jobExecution->getStatus()->willReturn($status);
$jobExecution->getJobInstance()->willReturn($jobInstance);
$stepExecution->getWarnings()->willReturn($warnings);
$jobExecution->getId()->willReturn(5);
$jobInstance->getType()->willReturn('export');
$jobInstance->getLabel()->willReturn('Product export');
$event->getJobExecution()->willReturn($jobExecution);
}
/**
* @return array
*/
protected function readOrderedRawJobData()
{
$rawJobs = [];
$fileLocator = $this->getFileLocator();
foreach ($this->jobsFilePaths as $jobsFilePath) {
$yamlReader = $this->getYamlReader();
$realPath = $fileLocator->locate('@' . $jobsFilePath);
$jobExecution = new JobExecution();
$jobParameters = new JobParameters(['filePath' => $realPath]);
$jobExecution->setJobParameters($jobParameters);
$stepExecution = new StepExecution('reader', $jobExecution);
$yamlReader->setStepExecution($stepExecution);
while ($rawJob = $yamlReader->read()) {
$rawJobs[] = $rawJob;
}
usort($rawJobs, function ($item1, $item2) {
if ($item1['order'] === $item2['order']) {
return 0;
}
return $item1['order'] < $item2['order'] ? -1 : 1;
});
}
return $rawJobs;
}
function it_marks_a_job_execution_as_failed($entityManager, JobExecution $jobExecution)
{
$jobExecution->setStatus(Argument::any())->shouldBeCalled();
$jobExecution->setExitStatus(Argument::any())->shouldBeCalled();
$jobExecution->setEndTime(Argument::any())->shouldBeCalled();
$jobExecution->addFailureException(Argument::any())->shouldBeCalled();
$entityManager->persist($jobExecution)->shouldBeCalled();
$entityManager->flush()->shouldBeCalled();
$this->markAsFailed($jobExecution);
}
/**
* Returns true if the job has been executed without any warning
*
* @param JobExecution $jobExecution
*
* @return bool
*/
protected function executionComplete(JobExecution $jobExecution)
{
if (ExitStatus::COMPLETED !== $jobExecution->getExitStatus()->getExitCode()) {
return false;
}
foreach ($jobExecution->getStepExecutions() as $stepExecution) {
if (count($stepExecution->getWarnings())) {
return false;
}
}
return true;
}
/**
* @param JobExecution $jobExecution
* @param string|UserInterface $user
* @param string $type
* @param string $status
*/
protected function generateMassEditNotify(JobExecution $jobExecution, $user, $type, $status)
{
$this->manager->notify([$user], sprintf('pim_mass_edit.notification.%s.%s', $type, $status), $status, ['route' => 'pim_enrich_job_tracker_show', 'routeParams' => ['id' => $jobExecution->getId()], 'messageParams' => ['%label%' => $jobExecution->getJobInstance()->getLabel()], 'context' => ['actionType' => $type]]);
}
/**
* {@inheritdoc}
*/
public function supports(JobExecution $jobExecution)
{
if ($jobExecution->getJobParameters()->has('invalid_items_file_format')) {
return $this->invalidItemFileFormat === $jobExecution->getJobParameters()->get('invalid_items_file_format');
}
return false;
}
/**
* Default mapping from throwable to {@link ExitStatus}. Clients can modify the exit code using a
* {@link StepExecutionListener}.
*
* @param JobExecution $jobExecution Execution of the job
* @param string $status Status of the execution
*
* @return an {@link ExitStatus}
*/
private function updateStatus(JobExecution $jobExecution, $status)
{
$jobExecution->setStatus(new BatchStatus($status));
}
/**
* Get the relative archive path in the file system
*
* @param JobExecution $jobExecution
*
* @return string
*/
protected function getRelativeArchivePath(JobExecution $jobExecution)
{
$jobInstance = $jobExecution->getJobInstance();
return $jobInstance->getType() . DIRECTORY_SEPARATOR . $jobInstance->getAlias() . DIRECTORY_SEPARATOR . $jobExecution->getId() . DIRECTORY_SEPARATOR . $this->getName() . DIRECTORY_SEPARATOR . '%filename%';
}
/**
* Accessor for the job parameters
*
* @return JobParameters
*
*/
public function getJobParameters()
{
return $this->jobExecution->getJobParameters();
}
function it_executes(JobExecution $jobExecution, JobRepositoryInterface $jobRepository, EventDispatcherInterface $dispatcher, BatchStatus $status)
{
$this->setEventDispatcher($dispatcher);
$this->setJobRepository($jobRepository);
$jobExecution->getStatus()->willReturn($status);
$status->getValue()->willReturn(BatchStatus::UNKNOWN);
$dispatcher->dispatch(EventInterface::BEFORE_JOB_EXECUTION, Argument::any())->shouldBeCalled();
$jobExecution->setStartTime(Argument::any())->shouldBeCalled();
$jobExecution->setStatus(Argument::any())->shouldBeCalled();
$dispatcher->dispatch(EventInterface::AFTER_JOB_EXECUTION, Argument::any())->shouldBeCalled();
$jobExecution->setEndTime(Argument::any())->shouldBeCalled();
$this->execute($jobExecution);
}
