/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
protected function setUp()
{
$this->em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$this->doctrineHelper = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock();
$this->mailer = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Mailer\\DirectMailer')->disableOriginalConstructor()->getMock();
$this->mailerTransport = $this->getMockBuilder('\\Swift_Transport_EsmtpTransport')->disableOriginalConstructor()->getMock();
$this->mailer->expects($this->any())->method('getTransport')->will($this->returnValue($this->mailerTransport));
$this->emailEntityBuilder = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Builder\\EmailEntityBuilder')->disableOriginalConstructor()->getMock();
$this->emailOwnerProvider = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Provider\\EmailOwnerProvider')->disableOriginalConstructor()->getMock();
$this->dispatcher = $this->getMockBuilder('Symfony\\Component\\EventDispatcher\\EventDispatcherInterface')->disableOriginalConstructor()->getMock();
$this->emailActivityManager = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Manager\\EmailActivityManager')->disableOriginalConstructor()->getMock();
$this->securityFacade = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->setMethods(['getLoggedUser', 'getOrganization'])->disableOriginalConstructor()->getMock();
$this->emailOriginHelper = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Tools\\EmailOriginHelper')->setMethods(['setEmailModel', 'findEmailOrigin'])->disableOriginalConstructor()->getMock();
$this->userEmailOrigin = $this->getMockBuilder('Oro\\Bundle\\ImapBundle\\Entity\\UserEmailOrigin')->disableOriginalConstructor()->getMock();
$this->userEmailOrigin->expects($this->any())->method('getSmtpHost')->will($this->returnValue('abc'));
$this->userEmailOrigin->expects($this->any())->method('getSmtpPort')->will($this->returnValue(25));
$this->securityFacadeLink = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\DependencyInjection\\Utils\\ServiceLink')->setMethods(['getService'])->disableOriginalConstructor()->getMock();
$this->securityFacadeLink->expects($this->any())->method('getService')->will($this->returnValue($this->securityFacade));
$this->securityFacade->expects($this->any())->method('getOrganization')->will($this->returnValue($this->getTestOrganization()));
$this->doctrineHelper->expects($this->any())->method('getEntityManager')->with('OroEmailBundle:Email')->will($this->returnValue($this->em));
$folder = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailFolder')->disableOriginalConstructor()->getMock();
$this->userEmailOrigin->expects($this->any())->method('getFolder')->with(FolderType::SENT)->will($this->returnValue($folder));
$emailOriginRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$emailOriginRepo->expects($this->any())->method('findOneBy')->with(['internalName' => InternalEmailOrigin::BAP])->will($this->returnValue($this->userEmailOrigin));
$this->em->expects($this->any())->method('getRepository')->with('OroEmailBundle:InternalEmailOrigin')->will($this->returnValue($emailOriginRepo));
$this->emailProcessor = new Processor($this->doctrineHelper, $this->mailer, new EmailAddressHelper(), $this->emailEntityBuilder, $this->emailOwnerProvider, $this->emailActivityManager, $this->securityFacadeLink, $this->dispatcher, new Mcrypt(), $this->emailOriginHelper);
}
/**
* @dataProvider getPrefixDataProvider
*
* @param UserInterface|string|null $loggedUser
* @param string|null $expectedPrefix
*/
public function testGetPrefix($loggedUser, $expectedPrefix = null)
{
$this->securityFacade->expects($this->once())->method('getLoggedUser')->willReturn($loggedUser);
if (!$expectedPrefix) {
$this->setExpectedException('\\RuntimeException', 'This method must be called only for logged User or AccountUser');
}
$this->assertEquals($expectedPrefix, $this->resolver->getPrefix());
}
public function testOnResultBeforeSkipForBackendUser()
{
$this->securityfacade->expects($this->once())->method('getLoggedUser')->willReturn(new User());
$this->event->expects($this->never())->method('getQuery');
$this->event->expects($this->never())->method('getDatagrid');
$this->metadataProvider->expects($this->never())->method('getMetadata');
$this->listener->onResultBefore($this->event);
}
/**
* @param string $acl
* @param bool $isGranted
* @param bool $hasLoggedUser
* @param bool $expected
* @dataProvider processorIsAllowedProvider
*/
public function testProcessorIsAllowed($acl, $isGranted, $hasLoggedUser, $expected)
{
if (null !== $acl) {
$this->securityFacade->expects($this->any())->method('hasLoggedUser')->willReturn($hasLoggedUser);
$this->securityFacade->expects($this->any())->method('isGranted')->with($acl)->willReturn($isGranted);
}
$this->processor->setAcl($acl);
$this->assertEquals($expected, $this->processor->isAllowed());
}
public function testGetGridReturnsNullWhenDontHavePermissions()
{
$gridName = 'test-grid';
$acl = 'test-acl';
$configuration = $this->getMockBuilder('Oro\\Bundle\\DataGridBundle\\Datagrid\\Common\\DatagridConfiguration')->disableOriginalConstructor()->getMock();
$configuration->expects($this->once())->method('getAclResource')->will($this->returnValue($acl));
$this->manager->expects($this->once())->method('getConfigurationForGrid')->with($gridName)->will($this->returnValue($configuration));
$this->securityFacade->expects($this->once())->method('isGranted')->with($acl)->will($this->returnValue(false));
$this->assertNull($this->twigExtension->getGrid($gridName));
}
/**
* @param array $inputData
* @param array $expectedData
*
* @dataProvider getActionsProvider
*/
public function testGetActions(array $inputData, array $expectedData)
{
$this->record->expects($this->any())->method('getValue')->with('id')->willReturn($inputData['record']['id']);
$this->doctrine->expects($this->any())->method('getManagerForClass')->with($expectedData['class'])->willReturn($this->manager);
$this->manager->expects($this->any())->method('getReference')->with($expectedData['class'], $expectedData['id'])->willReturn($inputData['object']);
$this->securityFacade->expects($this->any())->method('isGranted')->willReturnCallback(function ($permission) use($inputData) {
return $inputData['isGranted'][$permission];
});
$this->assertEquals($expectedData['actions'], $this->actionPermissionProvider->getActions($this->record, $inputData['config']));
}
public function testProcessEvent()
{
$user = new User();
$user->setId(1);
$this->configManager->expects($this->once())->method('get')->with('diamante_desk.email_notification')->will($this->returnValue(true));
$this->securityFacade->expects($this->once())->method('getLoggedUser')->will($this->returnValue($user));
$event = $this->event();
$this->notificationDeliveryManager->expects($this->once())->method('add')->with($this->logicalAnd($this->isInstanceOf('\\Diamante\\DeskBundle\\Model\\Ticket\\Notifications\\TicketNotification'), $this->attributeEqualTo('ticketUniqueId', $event->getAggregateId()), $this->attributeEqualTo('author', $user), $this->attributeEqualTo('headerText', $event->getHeaderText()), $this->attributeEqualTo('subject', $event->getSubject()), $this->attributeEqualTo('attachments', $event->attachments()), $this->attribute($this->logicalAnd($this->isInstanceOf('\\ArrayIterator'), $this->arrayHasKey('Description'), $this->contains('New Description')), 'changeList')));
$this->subscriber->processEvent($event);
}
/**
* @param boolean $isRolePredefined
* @param boolean $isGranted
* @param array $expected
*
* @dataProvider getAccountUserRolePermissionProvider
*/
public function testGetAccountUserRolePermission($isRolePredefined, $isGranted, array $expected)
{
$this->record->expects($this->any())->method('getValue')->with($this->isType('string'))->willReturn($isRolePredefined);
$this->securityFacade->expects($isRolePredefined ? $this->once() : $this->never())->method('isGranted')->with($this->isType('string'))->willReturn($isGranted);
$result = $this->actionPermissionProvider->getAccountUserRolePermission($this->record);
$this->assertCount(count($this->accountUserRoleActionList), $result);
foreach ($this->accountUserRoleActionList as $action) {
$this->assertArrayHasKey($action, $result);
}
$this->assertEquals($expected, $result);
}
protected function setUp()
{
$this->encryptor = new Mcrypt('someKey');
$user = $this->getMockBuilder('Oro\\Bundle\\UserBundle\\Entity\\User')->setMethods(['getOrganization'])->getMock();
$organization = $this->getMock('Oro\\Bundle\\OrganizationBundle\\Entity\\Organization');
$user->expects($this->any())->method('getOrganization')->willReturn($organization);
$this->securityFacade = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->disableOriginalConstructor()->getMock();
$this->securityFacade->expects($this->any())->method('getLoggerUser')->willReturn($user);
$this->securityFacade->expects($this->any())->method('getOrganization')->willReturn($organization);
parent::setUp();
}
/**
* @dataProvider submitProvider
*
* @param AccountUser $defaultData
* @param array $submittedData
* @param AccountUser $expectedData
* @param bool|true $rolesGranted
*/
public function testSubmit(AccountUser $defaultData, array $submittedData, AccountUser $expectedData, $rolesGranted = true)
{
if ($rolesGranted) {
$this->securityFacade->expects($this->once())->method('isGranted')->with('orob2b_account_account_user_role_view')->will($this->returnValue(true));
}
$form = $this->factory->create($this->formType, $defaultData, []);
$this->assertEquals($defaultData, $form->getData());
$form->submit($submittedData);
$this->assertTrue($form->isValid());
$this->assertEquals($expectedData, $form->getData());
}
/**
* @param bool $isGranted
* @param bool $isFieldAclEnabled
* @param bool $isFieldGranted
*/
protected function configureSecurityMock($isGranted, $isFieldAclEnabled, $isFieldGranted)
{
$this->containerMock->expects($this->at(0))->method('get')->with('oro_security.security_facade')->willReturn($this->securityMock);
$this->securityMock->expects($this->at(0))->method('isGranted')->with('EDIT', 'entity:Test\\Entity')->willReturn($isGranted);
if ($isFieldAclEnabled) {
$this->containerMock->expects($this->at(3))->method('get')->with('oro_security.security_facade')->willReturn($this->securityMock);
$this->securityMock->expects($this->at(1))->method('isGranted')->with('EDIT', $this->isInstanceOf('Symfony\\Component\\Security\\Acl\\Voter\\FieldVote'))->willReturn($isFieldGranted);
$doctrineHelperMock = $this->getMockBuilder('Oro\\Bundle\\EntityBundle\\ORM\\DoctrineHelper')->disableOriginalConstructor()->getMock();
$doctrineHelperMock->expects($this->once())->method('createEntityInstance')->with('Test\\Entity')->willReturn(new \stdClass());
$this->containerMock->expects($this->at(4))->method('get')->with('oro_entity.doctrine_helper')->willReturn($doctrineHelperMock);
}
}
public function testFilterQueryByUserIdWhenNoMailboxesFound()
{
$user = new User();
$organization = new Organization();
$em = $this->getTestEntityManager();
$qb = $em->createQueryBuilder();
$this->securityFacade->expects($this->once())->method('getLoggedUser')->will($this->returnValue($user));
$this->securityFacade->expects($this->once())->method('getOrganization')->will($this->returnValue($organization));
$this->mailboxRepository->expects($this->any())->method('findAvailableMailboxIds')->with($user, $organization)->will($this->returnValue([1, 3, 5]));
$qb->select('eu')->from('EmailUser', 'eu');
$this->factory->applyAcl($qb, 1);
$this->assertEquals("SELECT eu FROM EmailUser eu" . " WHERE (eu.owner = :owner AND eu.organization = :organization) OR eu.mailboxOwner IN(:mailboxIds)", $qb->getQuery()->getDQL());
}
protected function setUp()
{
$user = $this->getMockBuilder('Oro\\Bundle\\UserBundle\\Entity\\User')->setMethods(['getOrganization'])->getMock();
$organization = $this->getMock('Oro\\Bundle\\OrganizationBundle\\Entity\\Organization');
$user->expects($this->any())->method('getOrganization')->willReturn($organization);
$this->securityFacade = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->disableOriginalConstructor()->getMock();
$this->securityFacade->expects($this->any())->method('getLoggerUser')->willReturn($user);
$this->securityFacade->expects($this->any())->method('getOrganization')->willReturn($organization);
$this->translator = $this->getMockBuilder('Oro\\Bundle\\TranslationBundle\\Translation\\Translator')->disableOriginalConstructor()->getMock();
$this->userConfigManager = $this->getMockBuilder('Oro\\Bundle\\ConfigBundle\\Config\\ConfigManager')->disableOriginalConstructor()->getMock();
$this->configProvider = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->setMethods(['hasConfig', 'getConfig', 'get'])->disableOriginalConstructor()->getMock();
parent::setUp();
}
/**
* @param array $params
* @param array $expected
*
* @dataProvider permissionsDataProvider
*/
public function testGetInvitationPermissions(array $params, array $expected)
{
$record = $this->getMock('Oro\\Bundle\\DataGridBundle\\Datasource\\ResultRecordInterface');
$user = new User();
$user->setId(self::ADMIN);
$this->securityFacade->expects($this->any())->method('getLoggedUser')->will($this->returnValue($user));
$record->expects($this->at(0))->method('getValue')->with('invitationStatus')->will($this->returnValue($params['invitationStatus']));
$record->expects($this->at(1))->method('getValue')->with('parentId')->will($this->returnValue($params['parentId']));
$record->expects($this->at(2))->method('getValue')->with('ownerId')->will($this->returnValue($params['ownerId']));
$record->expects($this->at(3))->method('getValue')->with('childrenCount')->will($this->returnValue($params['childrenCount']));
$result = $this->provider->getInvitationPermissions($record);
$this->assertEquals($expected, $result);
}
/**
* @return array
*/
protected function getExtensions()
{
$account = $this->getAccount(1);
$user = new AccountUser();
$user->setAccount($account);
$this->securityFacade->expects($this->any())->method('getLoggedUser')->willReturn($user);
$frontendUserRoleSelectType = new EntitySelectTypeStub($this->getRoles(), FrontendAccountUserRoleSelectType::NAME, new AccountUserRoleSelectType());
$addressEntityType = new EntityType($this->getAddresses(), 'test_address_entity');
$accountSelectType = new AccountSelectTypeStub($this->getAccounts(), 'orob2b_account_select');
$accountUserType = new AccountUserType($this->securityFacade);
$accountUserType->setDataClass(self::DATA_CLASS);
$accountUserType->setAddressClass(self::ADDRESS_CLASS);
return [new PreloadedExtension([OroDateType::NAME => new OroDateType(), AccountUserType::NAME => $accountUserType, FrontendAccountUserRoleSelectType::NAME => $frontendUserRoleSelectType, $accountSelectType->getName() => $accountSelectType, AddressCollectionTypeStub::NAME => new AddressCollectionTypeStub(), $addressEntityType->getName() => $addressEntityType], []), new ValidatorExtension(Validation::createValidator())];
}
/**
* @param boolean $atLeastOneGranted
* @dataProvider voteProvider
*/
public function testVote($atLeastOneGranted)
{
$token = $this->getMock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\TokenInterface');
$email = new Email();
$emailUser1 = new EmailUser();
$emailUser2 = new EmailUser();
$emailUser3 = new EmailUser();
$email->addEmailUser($emailUser1);
$email->addEmailUser($emailUser2);
$email->addEmailUser($emailUser3);
$attributes = ['VIEW'];
if ($atLeastOneGranted) {
$this->securityFacade->expects($this->once())->method('isGranted')->with('VIEW', ${'emailUser' . mt_rand(1, 3)})->willReturn(true);
}
$result = $atLeastOneGranted ? EmailVoter::ACCESS_GRANTED : EmailVoter::ACCESS_DENIED;
$this->assertEquals($result, $this->emailVoter->vote($token, $email, $attributes));
}
/**
* @dataProvider permissionsDataProvider
* @SuppressWarnings(PHPMD.ExcessiveParameterList)
*
* @param string $userClass
* @param string $addressType
* @param array|null $isGranted
* @param bool $hasAccountAddresses
* @param bool $hasAccountUserAddresses
* @param bool $hasEntity
* @param bool $isAddressGranted
* @param bool $isAccountAddressGranted
* @param bool $isAccountUserAddressGranted
*/
public function testIsAddressGranted($userClass, $addressType, $isGranted, $hasAccountAddresses, $hasAccountUserAddresses, $hasEntity, $isAddressGranted, $isAccountAddressGranted, $isAccountUserAddressGranted)
{
$this->orderAddressProvider->expects($this->any())->method('getAccountAddresses')->willReturn($hasAccountAddresses);
$this->orderAddressProvider->expects($this->any())->method('getAccountUserAddresses')->willReturn($hasAccountUserAddresses);
$this->securityFacade->expects($this->any())->method('getLoggedUser')->willReturn(new $userClass());
$this->securityFacade->expects($this->any())->method('isGranted')->with($this->isType('string'))->will($this->returnValueMap((array) $isGranted));
$order = null;
$account = null;
$accountUser = null;
if ($hasEntity) {
$account = new Account();
$accountUser = new AccountUser();
}
$order = (new Order())->setAccount($account)->setAccountUser($accountUser);
$this->assertEquals($isAddressGranted, $this->provider->isAddressGranted($order, $addressType));
$this->assertEquals($isAccountAddressGranted, $this->provider->isAccountAddressGranted($addressType, $account));
$this->assertEquals($isAccountUserAddressGranted, $this->provider->isAccountUserAddressGranted($addressType, $accountUser));
}
/**
* @dataProvider getTestData
*/
public function testLinkToScope($config, $managerCalls, $attachmentCalls)
{
$attachments = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailAttachment')->disableOriginalConstructor()->getMock();
$emailBody = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailBody')->disableOriginalConstructor()->getMock();
$email = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Email')->disableOriginalConstructor()->getMock();
$event = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Event\\EmailBodyAdded')->disableOriginalConstructor()->getMock();
$configInterface = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->disableOriginalConstructor()->getMock();
$this->securityFacade->expects($this->once())->method('getToken')->willReturn(1);
$this->securityFacade->expects($this->once())->method('isGranted')->willReturn(true);
$this->activityListProvider->expects($this->once())->method('getTargetEntities')->willReturn([new SomeEntity()]);
$configInterface->expects($this->once())->method('get')->will($this->returnValue($config));
$this->configProvider->expects($this->once())->method('getConfig')->will($this->returnValue($configInterface));
$this->emailAttachmentManager->expects($this->exactly($managerCalls))->method('linkEmailAttachmentToTargetEntity');
$emailBody->expects($this->exactly($attachmentCalls))->method('getAttachments')->will($this->returnValue([$attachments]));
$email->expects($this->exactly($attachmentCalls))->method('getEmailBody')->will($this->returnValue($emailBody));
$event->expects($this->exactly(1))->method('getEmail')->will($this->returnValue($email));
$this->listener->linkToScope($event);
}
/**
* @param int $userId
*/
protected function mockUser($userId)
{
/** @var AccountUser $user */
$user = $this->getEntity('\\OroB2B\\Bundle\\AccountBundle\\Entity\\AccountUser', $userId);
/** @var Account $account */
$account = $this->getEntity('\\OroB2B\\Bundle\\AccountBundle\\Entity\\Account', static::ACCOUNT_ID);
$user->setAccount($account);
$this->securityFacade->expects($this->any())->method('getLoggedUser')->willReturn($userId ? $user : null);
}
public function testAclConditionArrayFail()
{
$items = ['placeholder_item' => ['template' => 'template', 'acl' => ['acl_ancestor1', 'acl_ancestor2']]];
$variables = ['foo' => 'bar'];
$provider = $this->createProvider($items);
$this->securityFacade->expects($this->at(0))->method('isGranted')->with('acl_ancestor1')->will($this->returnValue(false));
$actual = $provider->getPlaceholderItems(self::TEST_PLACEHOLDER, $variables);
unset($items['placeholder_item']['acl']);
$this->assertSame([], $actual);
}
protected function setUp()
{
$account = $this->createAccount(1, 'account');
$user = new AccountUser();
$user->setAccount($account);
$this->qb = $this->getMockBuilder('Doctrine\\ORM\\QueryBuilder')->disableOriginalConstructor()->getMock();
$this->securityFacade = $this->getMockBuilder('Oro\\Bundle\\SecurityBundle\\SecurityFacade')->disableOriginalConstructor()->getMock();
$this->securityFacade->expects($this->any())->method('getLoggedUser')->willReturn($user);
$this->registry = $this->getMockBuilder('Doctrine\\Bundle\\DoctrineBundle\\Registry')->disableOriginalConstructor()->getMock();
/** @var $repo AccountUserRoleRepository|\PHPUnit_Framework_MockObject_MockObject */
$repo = $this->getMockBuilder('OroB2B\\Bundle\\AccountBundle\\Entity\\Repository\\AccountUserRoleRepository')->disableOriginalConstructor()->getMock();
$repo->expects($this->any())->method('getAvailableRolesByAccountUserQueryBuilder')->with($user)->willReturn($this->qb);
/** @var $em ObjectManager|\PHPUnit_Framework_MockObject_MockObject */
$em = $this->getMock('Doctrine\\Common\\Persistence\\ObjectManager');
$em->expects($this->any())->method('getRepository')->with('OroB2B\\Bundle\\AccountBundle\\Entity\\AccountUserRole')->willReturn($repo);
$this->registry->expects($this->any())->method('getManagerForClass')->willReturn($em);
$this->formType = new FrontendAccountUserRoleSelectType($this->securityFacade, $this->registry);
$this->formType->setRoleClass('OroB2B\\Bundle\\AccountBundle\\Entity\\AccountUserRole');
parent::setUp();
}
/**
* {@inheritdoc}
* @dataProvider supportedMethods
*/
public function testProcessSupportedRequest($method, $isValid, $isProcessed)
{
$organization = null;
if ($isValid) {
$organization = new Organization();
$organization->setName('test');
$organizationToken = $this->getMock('Oro\\Bundle\\SecurityBundle\\Authentication\\Token\\OrganizationContextTokenInterface');
$organizationToken->expects($this->any())->method('getOrganizationContext')->willReturn($organization);
$this->securityFacade->expects($this->any())->method('getToken')->willReturn($organizationToken);
$this->form->expects($this->at(2))->method('get')->with('passwordGenerate')->will($this->returnValue($this->passwordGenerateForm));
$this->form->expects($this->at(3))->method('get')->with('sendEmail')->will($this->returnValue($this->sendEmailForm));
$this->passwordGenerateForm->expects($this->once())->method('getData')->will($this->returnValue(false));
$this->sendEmailForm->expects($this->once())->method('getData')->will($this->returnValue(false));
}
$this->form->expects($this->any())->method('isValid')->will($this->returnValue($isValid));
$this->request->setMethod($method);
$this->form->expects($this->once())->method('submit')->with($this->request);
$this->assertEquals($isProcessed, $this->handler->process($this->entity));
if ($organization) {
$this->assertEquals($organization, $this->entity->getOrganization());
$this->assertTrue($this->entity->hasOrganization($organization));
}
}
/**
* @dataProvider idsProvider
*/
public function testApply($isGranted)
{
$request = new Request();
$request->attributes->set('id', 1);
$request->attributes->set('_controller', 'Oro\\Test::test');
$config = $this->createConfiguration('stdClass', array('id' => 'id'), 'arg');
$manager = $this->getMock('Doctrine\\Common\\Persistence\\ObjectManager');
$objectRepository = $this->getMock('Doctrine\\Common\\Persistence\\ObjectRepository');
$this->registry->expects($this->once())->method('getManagerForClass')->with('stdClass')->will($this->returnValue($manager));
$manager->expects($this->once())->method('getRepository')->with('stdClass')->will($this->returnValue($objectRepository));
$objectRepository->expects($this->any())->method('find')->will($this->returnValue($object = new \stdClass()));
$this->securityFacade->expects($this->once())->method('isGranted')->will($this->returnValue($isGranted));
if (!$isGranted) {
$this->setExpectedException('Symfony\\Component\\Security\\Core\\Exception\\AccessDeniedException', 'You do not get EDIT permission for this object');
}
$this->converter->apply($request, $config);
$this->assertTrue($request->attributes->get('_oro_access_checked'));
if (!$isGranted) {
$this->assertFalse($request->attributes->get('_oro_access_checked'));
} else {
$this->assertTrue($request->attributes->get('_oro_access_checked'));
}
}
/**
* @param array $inputData
* @param int $expectedResult
*
* @dataProvider voteProvider
*/
public function testVote(array $inputData, $expectedResult)
{
$object = $inputData['object'];
$class = is_object($object) ? get_class($object) : null;
$this->doctrineHelper->expects($this->any())->method('getEntityClass')->with($object)->willReturn($class);
$this->doctrineHelper->expects($this->any())->method('getSingleEntityIdentifier')->with($object, false)->willReturn($inputData['objectId']);
$this->securityFacade->expects($this->any())->method('isGranted')->with($inputData['isGrantedAttr'], $inputData['isGrantedDescr'])->willReturn($inputData['isGranted']);
$this->securityProvider->expects($this->any())->method('isGrantedViewBasic')->with($class)->willReturn($inputData['grantedViewBasic']);
$this->securityProvider->expects($this->any())->method('isGrantedViewLocal')->with($class)->willReturn($inputData['grantedViewLocal']);
$this->securityProvider->expects($this->any())->method('isGrantedEditBasic')->with($class)->willReturn($inputData['grantedEditBasic']);
$this->securityProvider->expects($this->any())->method('isGrantedEditLocal')->with($class)->willReturn($inputData['grantedEditLocal']);
$this->voter->setClassName($class);
/* @var $token TokenInterface|\PHPUnit_Framework_MockObject_MockObject */
$token = $this->getMock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\TokenInterface');
$token->expects($this->any())->method('getUser')->willReturn($inputData['user']);
$this->assertEquals($expectedResult, $this->voter->vote($token, $object, $inputData['attributes']));
}
/**
* @dataProvider accountUserAddressPermissions
* @param string $type
* @param array $expectedCalledPermissions
* @param string $calledRepositoryMethod
* @param array $addresses
* @param object $loggedUser
*/
public function testGetAccountUserAddresses($type, array $expectedCalledPermissions, $calledRepositoryMethod, array $addresses, $loggedUser)
{
$this->securityFacade->expects($this->any())->method('getLoggedUser')->will($this->returnValue($loggedUser));
$accountUser = new AccountUser();
$permissionsValueMap = [];
foreach ($expectedCalledPermissions as $permission => $decision) {
$permissionsValueMap[] = [$permission, null, $decision];
}
$this->securityFacade->expects($this->exactly(count($expectedCalledPermissions)))->method('isGranted')->will($this->returnValueMap($permissionsValueMap));
$repository = $this->assertAccountUserAddressRepositoryCall();
if ($calledRepositoryMethod) {
$repository->expects($this->once())->method($calledRepositoryMethod)->with($accountUser, $type, $this->aclHelper)->will($this->returnValue($addresses));
} else {
$repository->expects($this->never())->method($this->anything());
}
$this->assertEquals($addresses, $this->provider->getAccountUserAddresses($accountUser, $type));
// cache
$this->assertEquals($addresses, $this->provider->getAccountUserAddresses($accountUser, $type));
}
/**
* @param array $productIds
* @param array $productQuantities
* @param array $expectedLineItems
*
* @dataProvider itemDataProvider
*/
public function testCreateForShoppingList(array $productIds = [], array $productQuantities = [], array $expectedLineItems = [])
{
/** @var \PHPUnit_Framework_MockObject_MockObject|ShoppingList $shoppingList */
$shoppingList = $this->getMock('OroB2B\\Bundle\\ShoppingListBundle\\Entity\\ShoppingList');
$shoppingList->expects($this->any())->method('getId')->willReturn(1);
$accountUser = new AccountUser();
$shoppingList->expects($this->any())->method('getAccountUser')->willReturn($accountUser);
$this->securityFacade->expects($this->any())->method('hasLoggedUser')->willReturn(true);
$this->securityFacade->expects($this->any())->method('isGranted')->willReturn(true);
$this->manager->expects($this->once())->method('bulkAddLineItems')->with($this->callback(function (array $lineItems) use($expectedLineItems, $accountUser) {
/** @var LineItem $lineItem */
foreach ($lineItems as $key => $lineItem) {
/** @var LineItem $expectedLineItem */
$expectedLineItem = $expectedLineItems[$key];
$this->assertEquals($expectedLineItem->getQuantity(), $lineItem->getQuantity());
$this->assertEquals($accountUser, $lineItem->getAccountUser());
$this->assertInstanceOf('OroB2B\\Bundle\\ProductBundle\\Entity\\Product', $lineItem->getProduct());
$this->assertInstanceOf('OroB2B\\Bundle\\ProductBundle\\Entity\\ProductUnit', $lineItem->getUnit());
}
return true;
}), $shoppingList, $this->isType('integer'));
$this->handler->createForShoppingList($shoppingList, $productIds, $productQuantities);
}
public function testHandleUpdateNotAllowed()
{
$massActionMock = $this->getMock(MassActionInterface::class);
$datagridMock = $this->getMock('Oro\\Bundle\\DataGridBundle\\Datagrid\\DatagridInterface');
$iteratorMock = $this->getMock('Oro\\Bundle\\DataGridBundle\\Datasource\\Orm\\IterableResultInterface');
$entityName = 'Test\\EntityName';
$hasConfig = true;
$isEnabled = true;
$isGranted = false;
$data = [];
$this->actionRepoMock->expects($this->once())->method('getEntityName')->with($datagridMock)->will($this->returnValue($entityName));
$this->configMock->expects($this->once())->method('hasConfig')->with($entityName)->will($this->returnValue($hasConfig));
$this->configMock->expects($this->once())->method('getConfig')->with($entityName)->will($this->returnValue(new Config(new EntityConfigId('extend', $entityName), ['update_mass_action_enabled' => $isEnabled])));
$this->securityMock->expects($this->once())->method('isGranted')->with('EDIT', 'entity:' . $entityName)->will($this->returnValue($isGranted));
$this->actionRepoMock->expects($this->never())->method('batchUpdate');
$this->transMock->expects($this->once())->method('trans')->will($this->returnValue(uniqid()));
$options = ActionConfiguration::create(['success_message' => '', 'error_message' => '']);
$massActionMock->expects($this->any())->method('getOptions')->will($this->returnValue($options));
$this->transMock->expects($this->once())->method('trans')->with('', ['%error%' => 'Action not configured or not allowed']);
$this->loggerMock->expects($this->once())->method('debug');
$actionResponse = $this->handler->handle(new MassActionHandlerArgs($massActionMock, $datagridMock, $iteratorMock, $data));
$this->assertFalse($actionResponse->isSuccessful());
}
/**
* @dataProvider supportsDataProvider
*
* @param mixed $user
* @param bool $expectedResult
*/
public function testSupports($user, $expectedResult)
{
$this->securityFacade->expects($this->once())->method('getLoggedUser')->willReturn($user);
$this->assertEquals($expectedResult, $this->decisionMaker->supports());
}
/**
* @param object $user
* @param bool $expected
*
* @dataProvider supportsDataProvider
*/
public function testSupports($user, $expected)
{
$this->securityFacade->expects($this->once())->method('getLoggedUser')->willReturn($user);
$this->assertEquals($expected, $this->treeProvider->supports());
}
/**
* @param ResultRecordInterface $record
* @param array $actions
* @param array $expected
* @param bool $isAllowed
*
* @dataProvider permissionsDataProvider
*/
public function testGetActionsPermissions(ResultRecordInterface $record, array $actions, array $expected, $isAllowed)
{
$this->settingsProvider->expects($this->any())->method('isChannelApplicable')->will($this->returnValue(true));
$this->securityFacade->expects($this->any())->method('isGranted')->will($this->returnValue($isAllowed));
$this->assertEquals($expected, $this->provider->getActionsPermissions($record, $actions));
}
