/** * Checks whether integration has at least on connector that supports backward sync * * @param string $integrationType * * @return bool */ public function hasTwoWaySyncConnectors($integrationType) { $connectors = $this->registry->getRegisteredConnectorsTypes($integrationType, function (ConnectorInterface $connector) { return $connector instanceof TwoWaySyncConnectorInterface; }); return !$connectors->isEmpty(); }
protected function getExtensions() { $assetsHelper = $this->getMockBuilder('Symfony\\Component\\Templating\\Helper\\CoreAssetsHelper')->disableOriginalConstructor()->getMock(); $integrationType = $this->getMock('Oro\\Bundle\\IntegrationBundle\\Provider\\ChannelInterface'); $transportType = $this->getMock('Oro\\Bundle\\IntegrationBundle\\Provider\\TransportInterface'); $registry = new TypesRegistry(); $registry->addChannelType(self::TEST_TYPE, $integrationType); $registry->addTransportType(uniqid('transport'), self::TEST_TYPE, $transportType); $security = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->disableOriginalConstructor()->getMock(); $em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock(); $metadata = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadata')->disableOriginalConstructor()->getMock(); $em->expects($this->once())->method('getClassMetadata')->with($this->equalTo('OroUser:User'))->will($this->returnValue($metadata)); $metadata->expects($this->once())->method('getSingleIdentifierFieldName')->will($this->returnValue(self::TEST_ID_FIELD_NAME)); $searchHandler = $this->getMock('Oro\\Bundle\\FormBundle\\Autocomplete\\SearchHandlerInterface'); $searchHandler->expects($this->any())->method('getEntityName')->will($this->returnValue('OroUser:User')); $searchRegistry = new SearchRegistry(); $searchRegistry->addSearchHandler('acl_users', $searchHandler); $config = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface'); $config->expects($this->any())->method('has')->with($this->equalTo('grid_name'))->will($this->returnValue(true)); $config->expects($this->any())->method('get')->with($this->equalTo('grid_name'))->will($this->returnValue('test_grid')); $cp = $this->getMock('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProviderInterface'); $cp->expects($this->any())->method('getConfig')->will($this->returnValue($config)); $cm = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigManager')->disableOriginalConstructor()->getMock(); $cm->expects($this->any())->method('getProvider')->will($this->returnValue($cp)); $validator = new Validator(new ClassMetadataFactory(new LoaderChain([])), new ConstraintValidatorFactory(), new DefaultTranslator()); $settingsProvider = $this->getMockBuilder('OroCRM\\Bundle\\ChannelBundle\\Provider\\SettingsProvider')->disableOriginalConstructor()->getMock(); return [new PreloadedExtension(['oro_integration_channel_form' => $this->getChannelType($registry), 'oro_integration_type_select' => new IntegrationTypeSelectType($registry, $assetsHelper), 'oro_user_organization_acl_select' => new OrganizationUserAclSelectType(), 'oro_user_acl_select' => new UserAclSelectType(), 'oro_entity_create_or_select_inline' => new OroEntitySelectOrCreateInlineType($security, $cm), 'oro_jqueryselect2_hidden' => new OroJquerySelect2HiddenType($em, $searchRegistry, $cp), 'genemu_jqueryselect2_choice' => new Select2Type('choice'), 'genemu_jqueryselect2_hidden' => new Select2Type('hidden')], ['form' => [new FormTypeCsrfExtension($this->getMock('Symfony\\Component\\Form\\Extension\\Csrf\\CsrfProvider\\CsrfProviderInterface')), new FormTypeValidatorExtension($validator), new TooltipFormExtension()], 'oro_integration_channel_form' => [new IntegrationTypeExtension($settingsProvider)]])]; }
/** * Returns a list of available integration types * * @return array [{integration type} => [{attr1} => {val1}, ...], ...] */ protected function getAvailableIntegrationTypes() { if (null === $this->itemsCache) { $this->itemsCache = $this->registry->getAvailableIntegrationTypesDetailedData(); } return $this->itemsCache; }
public function testSchedule() { $testIntegrationType = 'testIntegrationType'; $testConnectorType = 'testConnectorType'; $testId = 22; $integration = new Integration(); $integration->setType($testIntegrationType); $integration->setEnabled(true); $ref = new \ReflectionProperty(get_class($integration), 'id'); $ref->setAccessible(true); $ref->setValue($integration, $testId); $this->typesRegistry->addChannelType($testIntegrationType, new TestIntegrationType()); $this->typesRegistry->addConnectorType($testConnectorType, $testIntegrationType, new TestTwoWayConnector()); $that = $this; $uow = $this->getMockBuilder('Doctrine\\ORM\\UnitOfWork')->disableOriginalConstructor()->getMock(); $this->em->expects($this->once())->method('getUnitOfWork')->will($this->returnValue($uow)); $metadataFactory = $this->getMockBuilder('Doctrine\\ORM\\Mapping\\ClassMetadataFactory')->disableOriginalConstructor()->getMock(); $metadataFactory->expects($this->once())->method('getMetadataFor')->will($this->returnValue(new ClassMetadata('testEntity'))); $this->em->expects($this->once())->method('getMetadataFactory')->will($this->returnValue($metadataFactory)); $uow->expects($this->once())->method('persist')->with($this->isInstanceOf('JMS\\JobQueueBundle\\Entity\\Job'))->will($this->returnCallback(function (Job $job) use($that, $testId, $testConnectorType) { $expectedArgs = ['--integration=' . $testId, sprintf('--connector=testConnectorType', $testConnectorType), '--params=a:0:{}']; $that->assertEquals($expectedArgs, $job->getArgs()); })); $uow->expects($this->once())->method('computeChangeSet'); $this->scheduler->schedule($integration, $testConnectorType, [], false); }
/** * {@inheritdoc} */ protected function getConnectors(array $entities) { $dictionaryConnectors = $this->typeRegistry->getRegisteredConnectorsTypes(ChannelType::TYPE, function (ConnectorInterface $connector) { return $connector instanceof DictionaryConnectorInterface; })->toArray(); $connectors = []; $initialConnectors = []; $isSupportedExtensionVersion = $this->transportEntity->isSupportedExtensionVersion(); $isExtensionInstalled = $this->transportEntity->getIsExtensionInstalled(); foreach ($entities as $entity) { $connectorName = $this->settingsProvider->getIntegrationConnectorName($entity); if ($connectorName) { $connector = $this->typeRegistry->getConnectorType(ChannelType::TYPE, $connectorName); if (!$connector) { continue; } $isExtensionApplicable = $connector instanceof ExtensionVersionAwareInterface ? $isSupportedExtensionVersion : $isExtensionInstalled; if ($isExtensionApplicable || !$isExtensionApplicable && !$connector instanceof ExtensionAwareInterface) { array_push($initialConnectors, $connectorName . InitialSyncProcessor::INITIAL_CONNECTOR_SUFFIX); array_push($connectors, $connectorName); } } } return array_merge(array_keys($dictionaryConnectors), $initialConnectors, $connectors); }
/** * @param BuildBefore $event */ public function statusGridBuildBefore(BuildBefore $event) { $params = $event->getDatagrid()->getParameters(); if ($params->has('integrationType')) { $type = $params->get('integrationType'); $connectorChoices = $this->typesRegistry->getAvailableConnectorsTypesChoiceList($type); $event->getDatagrid()->getConfig()->offsetSetByPath('[filters][columns][connector][options][field_options][choices]', $connectorChoices); } }
public function testSetDefaultOptions() { /** @var OptionsResolverInterface|\PHPUnit_Framework_MockObject_MockObject $resolver */ $resolver = $this->getMock('Symfony\\Component\\OptionsResolver\\OptionsResolverInterface'); $resolver->expects($this->once())->method('setDefaults')->with($this->isType('array')); $this->registry->expects($this->once())->method('getAvailableIntegrationTypesDetailedData')->will($this->returnValue(['testType1' => ["label" => "oro.type1.label", "icon" => "bundles/acmedemo/img/logo.png"], 'testType2' => ["label" => "oro.type2.label"]])); $this->assetHelper->expects($this->once())->method('getUrl')->will($this->returnArgument(0)); $this->type->setDefaultOptions($resolver); }
/** * Picks proper default owner field for form, based on type. * * @param FormInterface $form * @param string $type */ protected function setDefaultOwnerField(FormInterface $form, $type = null) { $type = $this->typesRegistry->getDefaultOwnerType($type); if ($type === DefaultOwnerTypeAwareInterface::BUSINESS_UNIT) { $this->addBusinessUnitField($form); } else { $this->addUserOwnerField($form); } }
public function testHasTwoWaySyncConnectors() { $testType = 'type2'; $testTypeThatHasConnectors = 'type1'; $this->typesRegistry->addChannelType($testType, new TestIntegrationType()); $this->typesRegistry->addChannelType($testTypeThatHasConnectors, new TestIntegrationType()); $this->typesRegistry->addConnectorType(uniqid('type'), $testType, new TestConnector()); $this->typesRegistry->addConnectorType(uniqid('type'), $testTypeThatHasConnectors, new TestTwoWayConnector()); $this->assertTrue($this->utils->hasTwoWaySyncConnectors($testTypeThatHasConnectors)); $this->assertFalse($this->utils->hasTwoWaySyncConnectors($testType)); }
/** * @expectedException \LogicException * @expectedExceptionMessage Unable to schedule job for "testConnectorType" connector type */ public function testScheduleConnectorError() { $testIntegrationType = 'testIntegrationType'; $testConnectorType = 'testConnectorType'; $integration = new Integration(); $integration->setType($testIntegrationType); $this->typesRegistry->addChannelType($testIntegrationType, new TestIntegrationType()); $this->typesRegistry->addConnectorType($testConnectorType, $testIntegrationType, new TestConnector()); $integration->setEnabled(true); $this->scheduler->schedule($integration, $testConnectorType); }
/** * @return array */ protected function getChoices() { $choices = []; $choicesData = $this->registry->getAvailableIntegrationTypesDetailedData(); foreach ($choicesData as $typeName => $data) { $attributes = []; if (!empty($data['icon'])) { $attributes['data-icon'] = $this->assetHelper->getUrl($data['icon']); } $choices[$typeName] = new ChoiceListItem($data['label'], $attributes); } return $choices; }
public function testGetTransportFromContext() { $testID = 1; $testTransport = new \stdClass(); $integration = new Integration(); $integration->setTransport($this->getMockForAbstractClass('Oro\\Bundle\\IntegrationBundle\\Entity\\Transport')); $context = $this->getMock('Oro\\Bundle\\ImportExportBundle\\Context\\ContextInterface'); $context->expects($this->once())->method('getOption')->with('channel')->will($this->returnValue($testID)); $this->repo->expects($this->once())->method('getOrLoadById')->with($testID)->will($this->returnValue($integration)); $this->registry->expects($this->once())->method('getTransportTypeBySettingEntity')->will($this->returnValue($testTransport)); $result = $this->contextMediator->getTransport($context); $this->assertEquals($testTransport, $result); }
/** * {@inheritdoc} */ public function finishView(FormView $view, FormInterface $form, array $options) { $typeData = $this->typesRegistry->getAvailableIntegrationTypesDetailedData(); /** @var ChoiceView $choiceView */ foreach ($view->vars['choices'] as $choiceView) { /** @var Integration $integration */ $integration = $choiceView->data; $attributes = ['data-status' => $integration->isEnabled()]; if (isset($typeData[$integration->getType()], $typeData[$integration->getType()]['icon'])) { $attributes['data-icon'] = $this->assetHelper->getUrl($typeData[$integration->getType()]['icon']); } $choiceView->label = new ChoiceListItem($choiceView->label, $attributes); } }
public function testSetDefaultOptions() { $resolver = new OptionsResolver(); $this->registry->expects($this->once())->method('getAvailableIntegrationTypesDetailedData')->will($this->returnValue(['testType1' => ['label' => 'oro.type1.label', 'icon' => 'bundles/acmedemo/img/logo.png'], 'testType2' => ['label' => 'oro.type2.label']])); $this->assetHelper->expects($this->once())->method('getUrl')->will($this->returnArgument(0)); $this->type->setDefaultOptions($resolver); $result = $resolver->resolve([]); $choiceAttr = []; foreach ($result['choices'] as $choice => $label) { $choiceAttr[$choice] = call_user_func($result['choice_attr'], $choice); } unset($result['choice_attr']); $this->assertEquals(['empty_value' => '', 'choices' => ['testType1' => 'oro.type1.label', 'testType2' => 'oro.type2.label'], 'configs' => ['placeholder' => 'oro.form.choose_value', 'result_template_twig' => 'OroIntegrationBundle:Autocomplete:type/result.html.twig', 'selection_template_twig' => 'OroIntegrationBundle:Autocomplete:type/selection.html.twig']], $result); $this->assertEquals(['testType1' => ['data-icon' => 'bundles/acmedemo/img/logo.png'], 'testType2' => []], $choiceAttr); }
public function testFinishView() { $this->registry->expects($this->once())->method('getAvailableIntegrationTypesDetailedData')->will($this->returnValue(['testType1' => ["label" => "oro.type1.label", "icon" => "bundles/acmedemo/img/logo.png"], 'testType2' => ["label" => "oro.type2.label"]])); $this->assetHelper->expects($this->once())->method('getUrl')->will($this->returnArgument(0)); $testIntegration1 = new Integration(); $testIntegration1->setType('testType1'); $testIntegration1Label = uniqid('label'); $testIntegration1Id = uniqid('id'); $testIntegration2 = new Integration(); $testIntegration2->setType('testType2'); $testIntegration2Label = uniqid('label'); $testIntegration2Id = uniqid('id'); $view = new FormView(); $view->vars['choices'] = [new ChoiceView($testIntegration1, $testIntegration1Id, $testIntegration1Label), new ChoiceView($testIntegration2, $testIntegration2Id, $testIntegration2Label)]; $this->type->finishView($view, $this->getMock('Symfony\\Component\\Form\\Test\\FormInterface'), []); $this->assertEquals($testIntegration1Label, $view->vars['choices'][0]->label); $this->assertEquals($testIntegration2Label, $view->vars['choices'][1]->label); $this->assertEquals(['data-status' => true, 'data-icon' => 'bundles/acmedemo/img/logo.png'], $view->vars['choices'][0]->attr); }
public function testOnChannelSucceedSave() { $this->entity->setChannelType(ChannelType::TYPE); $transport = new MagentoSoapTransport(); $transport->setIsExtensionInstalled(false); $this->integration->setTransport($transport); $this->typesRegistry->expects($this->any())->method('getRegisteredConnectorsTypes')->willReturn(new ArrayCollection([])); $this->prepareEvent(); $this->getListener()->onChannelSucceedSave($this->event); }
/** * @param array $data * @param FormInterface $form */ protected function modify($data, FormInterface $form) { if ($this->hasChannelParent($form)) { $connectors = $form->getParent()->get('connectors'); if ($connectors) { $config = $connectors->getConfig()->getOptions(); unset($config['choice_list']); unset($config['choices']); } else { $config = []; } if (array_key_exists('auto_initialize', $config)) { $config['auto_initialize'] = false; } $allowedTypesChoices = $this->typeRegistry->getAvailableConnectorsTypesChoiceList('magento', function (ConnectorInterface $connector) use($data) { return $connector instanceof ExtensionAwareInterface ? $data : true; }); $form->getParent()->add('connectors', 'choice', array_merge($config, ['choices' => $allowedTypesChoices])); } }
public function testPreSetWithBusinessUnitDefaultOwnerTypeAndExistingSameField() { $integration = $this->getMock('Oro\\Bundle\\IntegrationBundle\\Entity\\Channel'); $integration->expects($this->any())->method('getType')->will($this->returnValue('integration_type')); $this->typesRegistry->expects($this->any())->method('getDefaultOwnerType')->with($this->equalTo('integration_type'))->will($this->returnValue(DefaultOwnerTypeAwareInterface::BUSINESS_UNIT)); $form = $this->getMock('Symfony\\Component\\Form\\Test\\FormInterface'); $form->expects($this->at(0))->method('has')->with($this->equalTo('defaultUserOwner'))->will($this->returnValue(false)); $form->expects($this->at(1))->method('has')->with($this->equalTo('defaultBusinessUnitOwner'))->will($this->returnValue(true)); $form->expects($this->never())->method('add'); $event = new FormEvent($form, $integration); $this->subscriber->preSet($event); }
/** * Schedules backward sync job * * @param Integration $integration * @param string $connectorType * @param array $params * @param bool $useFlush * * @throws LogicException */ public function schedule(Integration $integration, $connectorType, $params = [], $useFlush = true) { if (!$integration->getEnabled()) { return; } $connector = $this->typesRegistry->getConnectorType($integration->getType(), $connectorType); if (!$connector instanceof TwoWaySyncConnectorInterface) { throw new LogicException(sprintf('Unable to schedule job for "%s" connector type', $connectorType)); } $args = ['--integration=' . $integration->getId(), '--connector=' . $connectorType, '--params=' . serialize($params)]; $job = new Job(self::JOB_NAME, $args); if ($useFlush) { $this->em->persist($job); $this->em->flush(); } else { $uow = $this->em->getUnitOfWork(); $uow->persist($job); $jobMeta = $this->em->getMetadataFactory()->getMetadataFor('JMS\\JobQueueBundle\\Entity\\Job'); $uow->computeChangeSet($jobMeta, $job); } }
public function testGetInitializedTransport() { $testTransport = $this->getMock('Oro\\Bundle\\IntegrationBundle\\Provider\\TransportInterface'); $transportEntity = $this->getMockForAbstractClass('Oro\\Bundle\\IntegrationBundle\\Entity\\Transport'); $integration = new Integration(); $integration->setTransport($transportEntity); $this->registry->expects($this->once())->method('getTransportTypeBySettingEntity')->will($this->returnValue($testTransport)); $testTransport->expects($this->once())->method('init')->with($transportEntity); $result = $this->contextMediator->getInitializedTransport($integration); $this->assertEquals($testTransport, $result); // test local cache $this->contextMediator->getInitializedTransport($integration); }
/** * Schedules backward sync job * * @param Integration $integration * @param string $connectorType * @param array $params * @param bool $useFlush * * @throws LogicException */ public function schedule(Integration $integration, $connectorType, $params = [], $useFlush = true) { if (!$integration->isEnabled()) { return; } $connector = $this->typesRegistry->getConnectorType($integration->getType(), $connectorType); if (!$connector instanceof TwoWaySyncConnectorInterface) { throw new LogicException(sprintf('Unable to schedule job for "%s" connector type', $connectorType)); } $args = ['--integration=' . $integration->getId(), '--connector=' . $connectorType, '--params=' . serialize($params)]; if (!$this->isScheduled($args)) { $job = new Job(self::JOB_NAME, $args); /** @var EntityManager $em */ $em = $this->registry->getManagerForClass('JMSJobQueueBundle:Job'); $em->persist($job); if (true === $useFlush) { $em->flush(); } else { $jobMeta = $em->getClassMetadata('JMSJobQueueBundle:Job'); $em->getUnitOfWork()->computeChangeSet($jobMeta, $job); } } }
/** * @param array $connectors * @param \DateTime $syncStartDate * @param object|null $realConnector * @return Channel|\PHPUnit_Framework_MockObject_MockObject */ protected function getIntegration(array $connectors = [], \DateTime $syncStartDate = null, $realConnector = null) { $integration = $this->getMockBuilder('Oro\\Bundle\\IntegrationBundle\\Entity\\Channel')->disableOriginalConstructor()->getMock(); $integration->expects($this->any())->method('getConnectors')->will($this->returnValue($connectors)); $integration->expects($this->any())->method('getId')->will($this->returnValue('testChannel')); $integration->expects($this->any())->method('getType')->will($this->returnValue('testChannelType')); $transport = new MagentoSoapTransport(); if ($syncStartDate) { $transport->setSyncStartDate($syncStartDate); } $integration->expects($this->any())->method('getTransport')->will($this->returnValue($transport)); $integration->expects($this->any())->method('isEnabled')->will($this->returnValue(true)); if (!$realConnector) { $realConnector = new TestConnector(); } $this->typesRegistry->expects($this->any())->method('getConnectorType')->will($this->returnValue($realConnector)); return $integration; }
/** * Process integration connector * * @param Integration $integration Integration object * @param string $connector Connector name * @param array $parameters Connector additional parameters * @param boolean $saveStatus Do we need to save new status to bd * * @return boolean */ protected function processIntegrationConnector(Integration $integration, $connector, array $parameters = [], $saveStatus = true) { if (!$integration->getEnabled()) { return false; } try { $this->logger->info(sprintf('Start processing "%s" connector', $connector)); // Clone object here because it will be modified and changes should not be shared between $realConnector = clone $this->registry->getConnectorType($integration->getType(), $connector); $jobName = $realConnector->getImportJobName(); $processorAliases = $this->processorRegistry->getProcessorAliasesByEntity(ProcessorRegistry::TYPE_IMPORT, $realConnector->getImportEntityFQCN()); } catch (\Exception $e) { // log and continue $this->logger->error($e->getMessage()); $status = new Status(); $status->setCode(Status::STATUS_FAILED)->setMessage($e->getMessage())->setConnector($connector); $this->doctrineRegistry->getRepository('OroIntegrationBundle:Channel')->addStatus($integration, $status); return false; } $configuration = [ProcessorRegistry::TYPE_IMPORT => array_merge(['processorAlias' => reset($processorAliases), 'entityName' => $realConnector->getImportEntityFQCN(), 'channel' => $integration->getId(), 'channelType' => $integration->getType()], $parameters)]; return $this->processImport($connector, $jobName, $configuration, $integration, $saveStatus); }
/** * Modifies form based on submitted data * * @param FormEvent $event */ public function preSubmit(FormEvent $event) { $form = $event->getForm(); /** @var Integration $originalData */ $originalData = $form->getData(); $data = $event->getData(); $this->muteFields($form, $originalData); if (!empty($data['type'])) { $type = $data['type']; $transportTypeModifier = $this->getTransportTypeModifierClosure($type); $transportTypeModifier($form); $connectorsModifier = $this->getConnectorsModifierClosure($type); $connectorsModifier($form); $synchronizationSettingsModifier = $this->getDynamicModifierClosure($type, 'synchronization_settings'); $synchronizationSettingsModifier($form); $mappingSettingsModifier = $this->getDynamicModifierClosure($type, 'mapping_settings'); $mappingSettingsModifier($form); // value that was set on postSet is replaced by null from request $typeChoices = array_keys($form->get('transportType')->getConfig()->getOption('choices')); $firstChoice = reset($typeChoices); $data['transportType'] = isset($data['transportType']) ? $data['transportType'] : $firstChoice; /* * If transport type changed we have to modify ViewData(it's already saved entity) * due to it's not matched the 'data_class' option of newly added form type */ if ($originalData !== null && ($transport = $originalData->getTransport())) { $transportType = $this->registry->getTransportTypeBySettingEntity($transport, $originalData->getType(), true); // second condition cover case when we have same name for few integration types if ($transportType !== $data['transportType'] || $originalData->getType() !== $data['type']) { /** @var Integration $setEntity */ $setEntity = $form->getViewData(); $setEntity->clearTransport(); } } $transportModifier = $this->getTransportModifierClosure($type, $data['transportType']); $transportModifier($form); $event->setData($data); } }
public function testGetRegisteredTransportTypes() { $this->assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $this->typesRegistry->getRegisteredTransportTypes(self::CHANNEL_TYPE_ONE)); }
/** * Clone object here because it will be modified and changes should not be shared between * * @param Integration $integration * @param string $connector * * @return TwoWaySyncConnectorInterface */ protected function getRealConnector(Integration $integration, $connector) { return clone $this->registry->getConnectorType($integration->getType(), $connector); }