public function setUp()
{
$this->fixtures = ['primaryEmail' => [1 => (new EmailAddress(1))->setEmail('*****@*****.**'), 2 => (new EmailAddress(2))->setEmail('*****@*****.**')], 'email' => ['*****@*****.**' => (new EmailAddress(1))->setEmail('*****@*****.**'), '*****@*****.**' => (new EmailAddress(2))->setEmail('*****@*****.**')]];
$emailOwnerProvider = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\Provider\\EmailOwnerProviderInterface');
$emailOwnerProvider->expects($this->any())->method('getEmailOwnerClass')->will($this->returnValue('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures\\TestEmailOwner'));
$this->emailOwnerProviderStorage = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Provider\\EmailOwnerProviderStorage')->disableOriginalConstructor()->getMock();
$this->emailOwnerProviderStorage->expects($this->any())->method('getProviders')->will($this->returnValue([$emailOwnerProvider, $emailOwnerProvider]));
$this->emailOwnerProviderStorage->expects($this->any())->method('getEmailOwnerFieldName')->will($this->onConsecutiveCalls('primaryEmail', 'homeEmail'));
$emailAddressRepository = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$emailAddressRepository->expects($this->any())->method('findOneBy')->will($this->returnCallback(function (array $criteria) {
return $this->findEmailAddressBy($criteria['email']);
}));
$emailAddressRepository->expects($this->any())->method('findBy')->will($this->returnCallback(function (array $criteria) {
$keys = array_keys($criteria);
$owner = $criteria[$keys[0]];
$emailAddress = $this->findEmailAddressBy($owner->getId(), $keys[0]);
if ($emailAddress) {
return [$emailAddress];
}
return [];
}));
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$this->emailAddressManager = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\Manager\\EmailAddressManager')->disableOriginalConstructor()->getMock();
$this->emailAddressManager->expects($this->any())->method('getEmailAddressRepository')->will($this->returnValue($emailAddressRepository));
$this->emailAddressManager->expects($this->any())->method('newEmailAddress')->will($this->returnValue(new EmailAddress()));
$this->emailAddressManager->expects($this->any())->method('getEntityManager')->will($this->returnValue($em));
$this->emailOwnerManager = new EmailOwnerManager($this->emailOwnerProviderStorage, $this->emailAddressManager);
}
public function testGetEmailAddressRepository()
{
$manager = new EmailAddressManager('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures', 'Test%sProxy');
$repo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$em->expects($this->once())->method('getRepository')->with($this->equalTo('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures\\TestEmailAddressProxy'))->will($this->returnValue($repo));
$this->assertTrue($repo === $manager->getEmailAddressRepository($em));
}
/**
* Gets a list of email addresses which have an owner
* Email addresses are sorted by modification date; newest at the top
*
* @return EmailAddress[]
*/
protected function getKnownEmailAddresses()
{
$this->log->notice('Loading known email addresses ...');
$repo = $this->emailAddressManager->getEmailAddressRepository($this->em);
$query = $repo->createQueryBuilder('a')->select('partial a.{id, email, updated}')->where('a.hasOwner = ?1')->orderBy('a.updated', 'DESC')->setParameter(1, true)->getQuery();
$emailAddresses = $query->getResult();
$this->log->notice(sprintf('Loaded %d email address(es).', count($emailAddresses)));
return $emailAddresses;
}
/**
* @param array $bindings
* @param EntityManager $em
*/
protected function persistBindings(array &$bindings, EntityManager $em)
{
$repository = $this->emailAddressManager->getEmailAddressRepository($em);
foreach ($bindings['changes'] as $item) {
$email = $item['email'];
$owner = false === $item['owner'] ? null : $item['owner'];
$emailAddress = $repository->findOneBy(['email' => $email]);
if ($emailAddress === null) {
$emailAddress = $this->emailAddressManager->newEmailAddress()->setEmail($email)->setOwner($owner);
$em->persist($emailAddress);
$this->computeEntityChangeSet($em, $emailAddress);
} elseif ($emailAddress->getOwner() !== $owner) {
$emailAddress->setOwner($owner);
$this->computeEntityChangeSet($em, $emailAddress);
}
}
foreach ($bindings['deletions'] as $owner) {
foreach ($this->emailOwnerClasses as $fieldName => $ownerClass) {
if (is_a($owner, $ownerClass)) {
$condition = array($fieldName => $owner);
/** @var EmailAddress[] $emailAddresses */
$emailAddresses = $repository->findBy($condition);
foreach ($emailAddresses as $emailAddress) {
$emailAddress->setOwner(null);
$this->computeEntityChangeSet($em, $emailAddress);
}
}
}
}
}
/**
* @param string $emailAddress
* @param string|null $ownerClass
* @param mixed|null $ownerId
*/
protected function preciseFullEmailAddress(&$emailAddress, $ownerClass = null, $ownerId = null)
{
if (!$this->emailAddressHelper->isFullEmailAddress($emailAddress)) {
if (!empty($ownerClass) && !empty($ownerId)) {
$owner = $this->entityRoutingHelper->getEntity($ownerClass, $ownerId);
if ($owner) {
$ownerName = $this->nameFormatter->format($owner);
if (!empty($ownerName)) {
$emailAddress = $this->emailAddressHelper->buildFullEmailAddress($emailAddress, $ownerName);
return;
}
}
}
$repo = $this->emailAddressManager->getEmailAddressRepository($this->em);
$emailAddressObj = $repo->findOneBy(array('email' => $emailAddress));
if ($emailAddressObj) {
$owner = $emailAddressObj->getOwner();
if ($owner) {
$ownerName = $this->nameFormatter->format($owner);
if (!empty($ownerName)) {
$emailAddress = $this->emailAddressHelper->buildFullEmailAddress($emailAddress, $ownerName);
}
}
}
}
}
/**
* @param EntityManager $em
*
* @return EntityRepository
*/
protected function getEmailAddressRepository(EntityManager $em)
{
if (null === $this->emailAddressRepository) {
$this->emailAddressRepository = $this->emailAddressManager->getEmailAddressRepository($em);
}
return $this->emailAddressRepository;
}
/**
* @param string[] $emailsToLoad
*
* @return array
* key = email address
* value = array
* known => true/false
* false if the address belongs to user only
* true if the address belongs to not excluded owners
* user => user id
*/
protected function getKnownEmailAddresses(array $emailsToLoad)
{
$repo = $this->emailAddressManager->getEmailAddressRepository($this->em);
$qb = $repo->createQueryBuilder('a')->where('a.hasOwner = :hasOwner AND a.email IN (:emails)')->setParameter('hasOwner', true)->setParameter('emails', $emailsToLoad);
$select = 'a.email';
$userIdField = null;
$mailboxIdField = null;
$ownerIdFields = [];
foreach ($this->emailOwnerProviderStorage->getProviders() as $provider) {
$ownerClass = $provider->getEmailOwnerClass();
$isUser = $ownerClass === 'Oro\\Bundle\\UserBundle\\Entity\\User';
$isMailbox = $ownerClass === 'Oro\\Bundle\\EmailBundle\\Entity\\Mailbox';
$field = $this->emailOwnerProviderStorage->getEmailOwnerFieldName($provider);
if ($isUser) {
$userIdField = $field;
}
if ($isMailbox) {
$mailboxIdField = $field;
}
if (isset($this->exclusions[$ownerClass])) {
if ($isUser) {
$select .= sprintf(',IDENTITY(a.%1$s) AS %1$s', $field);
} else {
$qb->andWhere(sprintf('a.%s IS NULL', $field));
}
} else {
$select .= sprintf(',IDENTITY(a.%1$s) AS %1$s', $field);
$ownerIdFields[] = $field;
}
}
$qb->select($select);
$data = $qb->getQuery()->getArrayResult();
$result = $this->prepareKnownEmailAddressesData($data, $ownerIdFields, $userIdField, $mailboxIdField);
return $result;
}
/**
* @param array $emailOwnerChanges
*
* @return EmailAddress[]
*/
protected function updateEmailAddresses(array $emailOwnerChanges, array $emailOwnerDeletions)
{
$updatedEmailAddresses = [];
foreach ($emailOwnerChanges as $item) {
$email = $item['email'];
$newOwner = false === $item['owner'] ? null : $item['owner'];
$emailAddress = $this->emailAddressManager->getEmailAddressRepository()->findOneBy(['email' => $email]);
if ($emailAddress === null) {
$emailAddress = $this->emailAddressManager->newEmailAddress()->setEmail($email)->setOwner($newOwner);
$this->emailAddressManager->getEntityManager()->persist($emailAddress);
$updatedEmailAddresses[] = $emailAddress;
} elseif ($emailAddress->getOwner() !== $newOwner) {
$emailAddress->setOwner($newOwner);
$updatedEmailAddresses[] = $emailAddress;
}
}
foreach ($emailOwnerDeletions as $owner) {
foreach ($this->emailOwnerClasses as $fieldName => $ownerClass) {
if (is_a($owner, $ownerClass)) {
$condition = array($fieldName => $owner);
/* @var $emailAddresses EmailAddress[] */
$emailAddresses = $this->emailAddressManager->getEmailAddressRepository()->findBy($condition);
foreach ($emailAddresses as $emailAddress) {
$emailAddress->setOwner(null);
$updatedEmailAddresses[] = $emailAddress;
}
}
}
}
return $updatedEmailAddresses;
}
/**
* @param string $emailAddress
* @param string|null $ownerClass
* @param mixed|null $ownerId
* @param bool $excludeCurrentUser
*/
public function preciseFullEmailAddress(&$emailAddress, $ownerClass = null, $ownerId = null, $excludeCurrentUser = false)
{
if (!$this->emailAddressHelper->isFullEmailAddress($emailAddress)) {
if (!empty($ownerClass) && !empty($ownerId)) {
$owner = $this->entityRoutingHelper->getEntity($ownerClass, $ownerId);
if ($owner) {
if ($this->doExcludeCurrentUser($excludeCurrentUser, $emailAddress, $owner)) {
return;
}
$ownerName = $this->entityNameResolver->getName($owner);
if (!empty($ownerName)) {
$emailAddress = $this->emailAddressHelper->buildFullEmailAddress($emailAddress, $ownerName);
return;
}
}
}
$repo = $this->emailAddressManager->getEmailAddressRepository($this->entityManager);
$emailAddressObj = $repo->findOneBy(array('email' => $emailAddress));
if ($emailAddressObj) {
$owner = $emailAddressObj->getOwner();
if ($owner) {
if ($this->doExcludeCurrentUser($excludeCurrentUser, $emailAddress, $owner)) {
return;
}
$ownerName = $this->entityNameResolver->getName($owner);
if (!empty($ownerName)) {
$emailAddress = $this->emailAddressHelper->buildFullEmailAddress($emailAddress, $ownerName);
}
}
}
}
}
/**
* Create EmailAddress entity object
*
* @param string $email The email address, for example: john@example.com or "John Smith" <*****@*****.**>
* @return EmailAddress
*/
public function address($email)
{
$pureEmail = EmailUtil::extractPureEmailAddress($email);
$result = $this->batch->getAddress($pureEmail);
if ($result === null) {
$result = $this->emailAddressManager->newEmailAddress()->setEmail($pureEmail);
$this->batch->addAddress($result);
}
return $result;
}
/**
* @param string $emailAddress
* @return string
*/
protected function preciseFullEmailAddress(&$emailAddress)
{
if (!EmailUtil::isFullEmailAddress($emailAddress)) {
$repo = $this->emailAddressManager->getEmailAddressRepository($this->em);
$emailAddressObj = $repo->findOneBy(array('email' => $emailAddress));
if ($emailAddressObj) {
$owner = $emailAddressObj->getOwner();
if ($owner) {
$emailAddress = EmailUtil::buildFullEmailAddress($emailAddress, $this->nameFormatter->format($owner));
}
}
}
}
public function testPreciseFulEmailAddressNoResult()
{
$emailAddress = $expected = '*****@*****.**';
$ownerClass = 'Oro\\Bundle\\UserBundle\\Entity\\User';
$ownerId = 2;
$this->entityRoutingHelper->expects($this->once())->method('getEntity')->with($ownerClass, $ownerId)->willReturn(null);
$repo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$repo->expects($this->once())->method('findOneBy')->willReturn(null);
$this->emailAddressManager->expects($this->once())->method('getEmailAddressRepository')->with($this->entityManager)->willReturn($repo);
$this->entityNameResolver->expects($this->never())->method('getName');
$this->helper->preciseFullEmailAddress($emailAddress, $ownerClass, $ownerId);
$this->assertEquals($emailAddress, $expected);
}
/**
* @param string[] $emailsToLoad
*
* @return array
* key = email address
* value = array
* known => true/false
* false if the address belongs to user only
* true if the address belongs to not excluded owners
* user => user id
*/
protected function getKnownEmailAddresses(array $emailsToLoad)
{
$repo = $this->emailAddressManager->getEmailAddressRepository($this->em);
$qb = $repo->createQueryBuilder('a')->where('a.hasOwner = :hasOwner AND a.email IN (:emails)')->setParameter('hasOwner', true)->setParameter('emails', $emailsToLoad);
$select = 'a.email';
$userIdField = null;
$mailboxIdField = null;
$ownerIdFields = [];
foreach ($this->emailOwnerProviderStorage->getProviders() as $provider) {
$ownerClass = $provider->getEmailOwnerClass();
$isUser = $ownerClass === 'Oro\\Bundle\\UserBundle\\Entity\\User';
$isMailbox = $ownerClass === 'Oro\\Bundle\\EmailBundle\\Entity\\Mailbox';
$field = $this->emailOwnerProviderStorage->getEmailOwnerFieldName($provider);
if ($isUser) {
$userIdField = $field;
}
if ($isMailbox) {
$mailboxIdField = $field;
}
if (isset($this->exclusions[$ownerClass])) {
if ($isUser) {
$select .= sprintf(',IDENTITY(a.%1$s) AS %1$s', $field);
} else {
$qb->andWhere(sprintf('a.%s IS NULL', $field));
}
} else {
$select .= sprintf(',IDENTITY(a.%1$s) AS %1$s', $field);
$ownerIdFields[] = $field;
}
}
$qb->select($select);
$result = [];
$data = $qb->getQuery()->getArrayResult();
foreach ($data as $item) {
$known = false;
foreach ($ownerIdFields as $field) {
if ($item[$field] !== null) {
$known = true;
break;
}
}
$email = strtolower($item['email']);
$userId = $item[$userIdField];
$mailboxId = $item[$mailboxIdField];
$result[$email] = $userId === null ? ['known' => $known] : ['known' => $known, 'user' => (int) $userId];
if ($mailboxId !== null) {
$result[$email]['mailbox'] = $mailboxId;
}
}
return $result;
}
/**
* Tell the given EntityManager to manage EmailAddress objects in this batch
*
* @param EntityManager $em
*/
protected function persistAddresses(EntityManager $em)
{
$repository = $this->emailAddressManager->getEmailAddressRepository($em);
foreach ($this->addresses as $key => $obj) {
/** @var EmailAddress $dbObj */
$dbObj = $repository->findOneBy(['email' => $obj->getEmail()]);
if ($dbObj === null) {
$obj->setOwner($this->emailOwnerProvider->findEmailOwner($em, $obj->getEmail()));
$em->persist($obj);
} else {
$this->updateAddressReferences($obj, $dbObj);
$this->addresses[$key] = $dbObj;
}
}
}
/**
* Loads the given emails into $this->knownEmailAddresses
*
* @param string[] $emailsToLoad
*/
protected function loadKnownEmailAddresses(array $emailsToLoad)
{
$this->log->notice(sprintf('Loading email address(es) "%s" ...', implode(',', $emailsToLoad)));
$repo = $this->emailAddressManager->getEmailAddressRepository($this->em);
$query = $repo->createQueryBuilder('a')->select('a.email')->where('a.hasOwner = ?1 AND a.email IN (?2)')->setParameter(1, true)->setParameter(2, $emailsToLoad)->getQuery();
$query->setHydrationMode(Query::HYDRATE_ARRAY);
$emails = $query->getResult();
$loadedEmailCount = count($emails);
foreach ($emails as $item) {
$email = strtolower($item['email']);
$this->knownEmailAddresses[$email] = 1;
// known
unset($emailsToLoad[$email]);
}
foreach ($emailsToLoad as $email) {
$this->knownEmailAddresses[$email] = -1;
// unknown
}
$this->log->notice(sprintf('Loaded %d email address(es).', $loadedEmailCount));
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testPersist()
{
$origin = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailOrigin')->getMock();
$origin->expects($this->any())->method('getId')->will($this->returnValue(1));
$this->batch->addOrigin($origin);
$folder = new EmailFolder();
$folder->setName('Exist');
$folder->setFullName('Exist');
$folder->setOrigin($origin);
$this->batch->addFolder($folder);
$newFolder = new EmailFolder();
$newFolder->setName('New');
$newFolder->setFullName('New');
$newFolder->setOrigin($origin);
$this->batch->addFolder($newFolder);
$dbFolder = new EmailFolder();
$dbFolder->setName('DbExist');
$dbFolder->setFullName('DbExist');
$dbFolder->setOrigin($origin);
$addr = $this->addrManager->newEmailAddress()->setEmail('Exist');
$this->batch->addAddress($addr);
$newAddr = $this->addrManager->newEmailAddress()->setEmail('New');
$this->batch->addAddress($newAddr);
$dbAddr = $this->addrManager->newEmailAddress()->setEmail('DbExist');
$email1 = new Email();
$email1->setFolder($folder);
$email1->setFromEmailAddress($addr);
$email1Recip1 = new EmailRecipient();
$email1Recip1->setEmailAddress($addr);
$email1Recip2 = new EmailRecipient();
$email1Recip2->setEmailAddress($newAddr);
$email1->addRecipient($email1Recip1);
$email1->addRecipient($email1Recip2);
$this->batch->addEmail($email1);
$email2 = new Email();
$email2->setFolder($newFolder);
$email2->setFromEmailAddress($newAddr);
$email2Recip1 = new EmailRecipient();
$email2Recip1->setEmailAddress($addr);
$email2Recip2 = new EmailRecipient();
$email2Recip2->setEmailAddress($newAddr);
$email2->addRecipient($email2Recip1);
$email2->addRecipient($email2Recip2);
$this->batch->addEmail($email2);
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$folderRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$addrRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$em->expects($this->exactly(2))->method('getRepository')->will($this->returnValueMap(array(array('OroEmailBundle:EmailFolder', $folderRepo), array('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures\\TestEmailAddressProxy', $addrRepo))));
$folderRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbFolder) {
return $c['fullName'] === 'Exist' ? $dbFolder : null;
}));
$addrRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbAddr) {
return $c['email'] === 'Exist' ? $dbAddr : null;
}));
$em->expects($this->exactly(4))->method('persist')->with($this->logicalOr($this->identicalTo($newFolder), $this->identicalTo($newAddr), $this->identicalTo($email1), $this->identicalTo($email2)));
$owner = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailOwnerInterface');
$this->ownerProvider->expects($this->any())->method('findEmailOwner')->will($this->returnValue($owner));
$this->batch->persist($em);
$this->assertTrue($origin === $email1->getFolder()->getOrigin());
$this->assertTrue($origin === $email2->getFolder()->getOrigin());
$this->assertTrue($dbFolder === $email1->getFolder());
$this->assertTrue($newFolder === $email2->getFolder());
$this->assertTrue($dbAddr === $email1->getFromEmailAddress());
$this->assertNull($email1->getFromEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2->getFromEmailAddress());
$this->assertTrue($owner === $email2->getFromEmailAddress()->getOwner());
$email1Recipients = $email1->getRecipients();
$this->assertTrue($dbAddr === $email1Recipients[0]->getEmailAddress());
$this->assertNull($email1Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email1Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email1Recipients[1]->getEmailAddress()->getOwner());
$email2Recipients = $email2->getRecipients();
$this->assertTrue($dbAddr === $email2Recipients[0]->getEmailAddress());
$this->assertNull($email2Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email2Recipients[1]->getEmailAddress()->getOwner());
}
/**
* Create EmailAddress entity object
*
* @param string $email
* @param EmailOwnerInterface $owner
* @return EmailAddress
*/
protected function createEmailAddress($email, EmailOwnerInterface $owner)
{
return $this->emailAddressManager->newEmailAddress()->setEmail($email)->setOwner($owner);
}
/**
* @param EmailAddressManager $emailAddressManager
*/
public function __construct(EmailAddressManager $emailAddressManager)
{
$this->emailAddressProxyClass = $emailAddressManager->getEmailAddressProxyClass();
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testPersist()
{
$origin = $this->getMockBuilder('Oro\\Bundle\\EmailBundle\\Entity\\EmailOrigin')->getMock();
$origin->expects($this->any())->method('getId')->will($this->returnValue(1));
$folder = new EmailFolder();
$folder->setName('Exist');
$folder->setFullName('Exist');
$folder->setOrigin($origin);
$this->batch->addFolder($folder);
$newFolder = new EmailFolder();
$newFolder->setName('New');
$newFolder->setFullName('New');
$newFolder->setOrigin($origin);
$this->batch->addFolder($newFolder);
$dbFolder = new EmailFolder();
$dbFolder->setName('DbExist');
$dbFolder->setFullName('DbExist');
$dbFolder->setOrigin($origin);
$addr = $this->addrManager->newEmailAddress()->setEmail('Exist');
$this->batch->addAddress($addr);
$newAddr = $this->addrManager->newEmailAddress()->setEmail('New');
$this->batch->addAddress($newAddr);
$dbAddr = $this->addrManager->newEmailAddress()->setEmail('DbExist');
$email1 = new Email();
$email1->setXMessageId('email1');
$email1->setMessageId('email1');
$email1->setFromEmailAddress($addr);
$emailUser1 = new EmailUser();
$emailUser1->addFolder($folder);
$emailUser1->setOrigin($origin);
$email1->addEmailUser($emailUser1);
$this->addEmailRecipient($email1, $addr);
$this->addEmailRecipient($email1, $newAddr);
$this->batch->addEmailUser($emailUser1);
$email2 = new Email();
$email2->setXMessageId('email2');
$email2->setMessageId('email2');
$email2->setFromEmailAddress($newAddr);
$emailUser2 = new EmailUser();
$emailUser2->addFolder($newFolder);
$emailUser2->setOrigin($origin);
$email2->addEmailUser($emailUser2);
$this->addEmailRecipient($email2, $addr);
$this->addEmailRecipient($email2, $newAddr);
$this->batch->addEmailUser($emailUser2);
$email3 = new Email();
$email3->setXMessageId('email3');
$email3->setMessageId('some_email');
$email3->setFromEmailAddress($newAddr);
$emailUser3 = new EmailUser();
$emailUser3->addFolder($folder);
$email3->addEmailUser($emailUser3);
$this->addEmailRecipient($email3, $addr);
$this->addEmailRecipient($email3, $newAddr);
$this->batch->addEmailUser($emailUser3);
$email4 = new Email();
$email4->setXMessageId('email4');
$email4->setMessageId('some_email');
$email4->setFromEmailAddress($newAddr);
$emailUser4 = new EmailUser();
$emailUser4->addFolder($folder);
$email4->addEmailUser($emailUser4);
$this->addEmailRecipient($email4, $addr);
$this->addEmailRecipient($email4, $newAddr);
$this->batch->addEmailUser($emailUser4);
$existingEmail = new Email();
$existingEmail->setXMessageId('existing_email');
$existingEmail->setMessageId('some_email');
$existingEmail->setFromEmailAddress($newAddr);
$emailUser5 = new EmailUser();
$emailUser5->addFolder($dbFolder);
$existingEmail->addEmailUser($emailUser5);
$this->addEmailRecipient($existingEmail, $addr);
$this->addEmailRecipient($existingEmail, $newAddr);
$em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->disableOriginalConstructor()->getMock();
$folderRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$addrRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$emailRepo = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
$em->expects($this->exactly(3))->method('getRepository')->will($this->returnValueMap(array(array('OroEmailBundle:EmailFolder', $folderRepo), array('Oro\\Bundle\\EmailBundle\\Tests\\Unit\\Entity\\TestFixtures\\TestEmailAddressProxy', $addrRepo), array('OroEmailBundle:Email', $emailRepo))));
$folderRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbFolder) {
return $c['fullName'] === 'Exist' ? $dbFolder : null;
}));
$addrRepo->expects($this->exactly(2))->method('findOneBy')->will($this->returnCallback(function ($c) use(&$dbAddr) {
return $c['email'] === 'Exist' ? $dbAddr : null;
}));
$emailRepo->expects($this->once())->method('findBy')->with(array('messageId' => array('email1', 'email2', 'some_email')))->will($this->returnValue([$existingEmail]));
$owner = $this->getMock('Oro\\Bundle\\EmailBundle\\Entity\\EmailOwnerInterface');
$this->ownerProvider->expects($this->any())->method('findEmailOwner')->will($this->returnValue($owner));
$this->batch->persist($em);
$this->assertCount(1, $email1->getEmailUsers());
$this->assertCount(1, $email2->getEmailUsers());
$this->assertTrue($origin === $emailUser1->getOrigin());
$this->assertTrue($origin === $emailUser2->getOrigin());
$this->assertSame($newFolder, $emailUser2->getFolders()->first());
$this->assertSame($dbFolder, $emailUser1->getFolders()->first());
$this->assertTrue($dbAddr === $email1->getFromEmailAddress());
$this->assertNull($email1->getFromEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2->getFromEmailAddress());
$this->assertTrue($owner === $email2->getFromEmailAddress()->getOwner());
$email1Recipients = $email1->getRecipients();
$this->assertTrue($dbAddr === $email1Recipients[0]->getEmailAddress());
$this->assertNull($email1Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email1Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email1Recipients[1]->getEmailAddress()->getOwner());
$email2Recipients = $email2->getRecipients();
$this->assertTrue($dbAddr === $email2Recipients[0]->getEmailAddress());
$this->assertNull($email2Recipients[0]->getEmailAddress()->getOwner());
$this->assertTrue($newAddr === $email2Recipients[1]->getEmailAddress());
$this->assertTrue($owner === $email2Recipients[1]->getEmailAddress()->getOwner());
$changes = $this->batch->getChanges();
$this->assertCount(3, $changes);
$this->assertSame($folder, $changes[0]['old']);
$this->assertSame($dbFolder, $changes[0]['new']);
$this->assertSame($email3, $changes[1]['old']);
$this->assertSame($existingEmail, $changes[1]['new']);
$this->assertSame($email4, $changes[2]['old']);
$this->assertSame($existingEmail, $changes[2]['new']);
}
