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); }