Cavemanon/piratepoet
8
Fork 0
Code Pull Requests Actions Releases 16 Activity

Replace \MailPoet\Tasks\Sending with Doctrine in SendingQueueTest

Browse Source 
This commit also removes Sending::getSendingQueueEntity() as the last
calls to this method were removed when refactoring SendingQueueTest.

[MAILPOET-5682]
This commit is contained in:
Rodrigo Primo
2023-11-21 16:45:27 -03:00
committed by Jan Jakeš
parent 75f7ea24a9
commit 876a9489a4
2 changed files with 110 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
mailpoet/lib/Tasks/Sending.php
View File

@@ -6,7 +6,6 @@ use MailPoet\Cron\Workers\SendingQueue\SendingQueue as SendingQueueAlias;
use MailPoet\DI\ContainerWrapper; use MailPoet\DI\ContainerWrapper;
use MailPoet\Entities\ScheduledTaskEntity; use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity; use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\InvalidStateException; use MailPoet\InvalidStateException;
use MailPoet\Logging\LoggerFactory; use MailPoet\Logging\LoggerFactory;
use MailPoet\Models\ScheduledTask; use MailPoet\Models\ScheduledTask;
@@ -225,16 +224,6 @@ class Sending {
return $this->queue; return $this->queue;
} }
public function getSendingQueueEntity(): SendingQueueEntity {
$sendingQueueEntity = $this->sendingQueuesRepository->findOneById($this->queue->id);
if (!$sendingQueueEntity) {
throw new InvalidStateException();
}
$this->sendingQueuesRepository->refresh($sendingQueueEntity);
return $sendingQueueEntity;
}
public function task() { public function task() {
return $this->task; return $this->task;
} }

276
mailpoet/tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php
View File

@@ -50,7 +50,6 @@ use MailPoet\Settings\TrackingConfig;
use MailPoet\Subscribers\LinkTokens; use MailPoet\Subscribers\LinkTokens;
use MailPoet\Subscribers\SubscribersRepository; use MailPoet\Subscribers\SubscribersRepository;
use MailPoet\Subscription\SubscriptionUrlFactory; use MailPoet\Subscription\SubscriptionUrlFactory;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\ScheduledTask as ScheduledTaskFactory; use MailPoet\Test\DataFactories\ScheduledTask as ScheduledTaskFactory;
use MailPoet\Test\DataFactories\Segment as SegmentFactory; use MailPoet\Test\DataFactories\Segment as SegmentFactory;
use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory; use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory;
@@ -63,8 +62,8 @@ class SendingQueueTest extends \MailPoetTest {
public $sendingQueueWorker; public $sendingQueueWorker;
public $cronHelper; public $cronHelper;
public $newsletterLink; public $newsletterLink;
/* @var SendingTask */ /* @var SendingQueueEntity */
public $queue; public $sendingQueue;
public $newsletterSegment; public $newsletterSegment;
public $newsletter; public $newsletter;
public $subscriberSegment; public $subscriberSegment;
@@ -104,10 +103,10 @@ class SendingQueueTest extends \MailPoetTest {
private $scheduledTaskSubscribersRepository; private $scheduledTaskSubscribersRepository;
/** @var ScheduledTaskEntity */ /** @var ScheduledTaskEntity */
private $scheduledTaskEntity; private $scheduledTask;
/** @var SendingQueueEntity */ /** NewsletterEntity */
private $sendingQueueEntity; private $newsletterEntity;
public function _before() { public function _before() {
parent::_before(); parent::_before();
@@ -117,6 +116,8 @@ class SendingQueueTest extends \MailPoetTest {
$populator = $this->diContainer->get(Populator::class); $populator = $this->diContainer->get(Populator::class);
$populator->up(); $populator->up();
$this->wp = $this->diContainer->get(WPFunctions::class); $this->wp = $this->diContainer->get(WPFunctions::class);
$this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
$this->scheduledTaskSubscribersRepository = $this->diContainer->get(ScheduledTaskSubscribersRepository::class);
$this->subscriber = $this->createSubscriber('john@doe.com', 'John', 'Doe'); $this->subscriber = $this->createSubscriber('john@doe.com', 'John', 'Doe');
/** @var Segment $segment */ /** @var Segment $segment */
$segment = Segment::create(); $segment = Segment::create();
@@ -139,26 +140,27 @@ class SendingQueueTest extends \MailPoetTest {
$this->newsletter->subject = Fixtures::get('newsletter_subject_template'); $this->newsletter->subject = Fixtures::get('newsletter_subject_template');
$this->newsletter->body = Fixtures::get('newsletter_body_template'); $this->newsletter->body = Fixtures::get('newsletter_body_template');
$this->newsletter->save(); $this->newsletter->save();
$this->newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $this->newsletterEntity);
/** @var NewsletterSegment $newsletterSegment */ /** @var NewsletterSegment $newsletterSegment */
$newsletterSegment = NewsletterSegment::create(); $newsletterSegment = NewsletterSegment::create();
$this->newsletterSegment = $newsletterSegment; $this->newsletterSegment = $newsletterSegment;
$this->newsletterSegment->newsletterId = $this->newsletter->id; $this->newsletterSegment->newsletterId = $this->newsletter->id;
$this->newsletterSegment->segmentId = (int)$this->segment->id; $this->newsletterSegment->segmentId = (int)$this->segment->id;
$this->newsletterSegment->save(); $this->newsletterSegment->save();
$this->queue = SendingTask::create();
$this->queue->newsletterId = $this->newsletter->id;
$this->queue->setSubscribers([$this->subscriber->getId()]);
$this->queue->countTotal = 1;
$this->queue->save();
$this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class); $this->sendingQueue = $this->createQueueWithTask($this->newsletterEntity);
$scheduledTask = $this->sendingQueue->getTask();
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
$this->scheduledTask = $scheduledTask;
$this->scheduledTaskSubscribersRepository->setSubscribers($this->scheduledTask, [$this->subscriber->getId()]);
$newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id); $queue = $this->newsletterEntity->getLatestQueue();
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$queue = $newsletterEntity->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue); $this->assertInstanceOf(SendingQueueEntity::class, $queue);
$this->newsletterLink = new NewsletterLinkEntity( $this->newsletterLink = new NewsletterLinkEntity(
$newsletterEntity, $this->newsletterEntity,
$queue, $queue,
'[link:subscription_instant_unsubscribe_url]', '[link:subscription_instant_unsubscribe_url]',
'abcde' 'abcde'
@@ -175,23 +177,13 @@ class SendingQueueTest extends \MailPoetTest {
$this->segmentsRepository = $this->diContainer->get(SegmentsRepository::class); $this->segmentsRepository = $this->diContainer->get(SegmentsRepository::class);
$this->tasksLinks = $this->diContainer->get(TasksLinks::class); $this->tasksLinks = $this->diContainer->get(TasksLinks::class);
$this->scheduledTasksRepository = $this->diContainer->get(ScheduledTasksRepository::class); $this->scheduledTasksRepository = $this->diContainer->get(ScheduledTasksRepository::class);
$this->scheduledTaskSubscribersRepository = $this->diContainer->get(ScheduledTaskSubscribersRepository::class);
$this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class); $this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class);
$this->sendingQueuesRepository = $this->diContainer->get(SendingQueuesRepository::class); $this->sendingQueuesRepository = $this->diContainer->get(SendingQueuesRepository::class);
$this->sendingQueueWorker = $this->getSendingQueueWorker(); $this->sendingQueueWorker = $this->getSendingQueueWorker();
$scheduledTaskEntity = $this->scheduledTasksRepository->findOneById($this->queue->taskId);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTaskEntity);
$this->scheduledTaskEntity = $scheduledTaskEntity;
$sendingQueueEntity = $this->sendingQueuesRepository->findOneById($this->queue->id);
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueueEntity);
$this->sendingQueueEntity = $sendingQueueEntity;
$this->entityManager->refresh($this->sendingQueueEntity);
} }
private function getDirectUnsubscribeURL() { private function getDirectUnsubscribeURL() {
return SubscriptionUrlFactory::getInstance()->getUnsubscribeUrl($this->subscriber, (int)$this->queue->id); return SubscriptionUrlFactory::getInstance()->getUnsubscribeUrl($this->subscriber, (int)$this->sendingQueue->getId());
} }
private function getTrackedUnsubscribeURL() { private function getTrackedUnsubscribeURL() {
@@ -200,7 +192,7 @@ class SendingQueueTest extends \MailPoetTest {
$data = $links->createUrlDataObject( $data = $links->createUrlDataObject(
$this->subscriber->getId(), $this->subscriber->getId(),
$linkTokens->getToken($this->subscriber), $linkTokens->getToken($this->subscriber),
$this->queue->id, $this->sendingQueue->getId(),
$this->newsletterLink->getHash(), $this->newsletterLink->getHash(),
false false
); );
@@ -285,14 +277,14 @@ class SendingQueueTest extends \MailPoetTest {
$this->entityManager $this->entityManager
); );
$sendingQueueWorker->sendNewsletters( $sendingQueueWorker->sendNewsletters(
$this->scheduledTaskEntity, $this->scheduledTask,
$preparedSubscribers = [], $preparedSubscribers = [],
$preparedNewsletters = [], $preparedNewsletters = [],
$preparedSubscribers = [], $preparedSubscribers = [],
$statistics[] = [ $statistics[] = [
'newsletter_id' => 1, 'newsletter_id' => 1,
'subscriber_id' => 1, 'subscriber_id' => 1,
'queue_id' => $this->queue->id, 'queue_id' => $this->sendingQueue->getId(),
], ],
microtime(true) microtime(true)
); );
@@ -302,10 +294,9 @@ class SendingQueueTest extends \MailPoetTest {
// when sending is done and there are no more subscribers to process, continue // when sending is done and there are no more subscribers to process, continue
// without enforcing execution limits. this allows the newsletter to be marked as sent // without enforcing execution limits. this allows the newsletter to be marked as sent
// in the process() method and after that execution limits will be enforced // in the process() method and after that execution limits will be enforced
$queue = $this->queue; $this->scheduledTask->setStatus(SendingQueue::STATUS_COMPLETED);
$queue->status = SendingQueue::STATUS_COMPLETED; $this->entityManager->persist($this->scheduledTask);
$queue->save(); $this->entityManager->flush();
$this->entityManager->refresh($this->scheduledTaskEntity);
$sendingQueueWorker = $this->make( $sendingQueueWorker = $this->make(
$this->getSendingQueueWorker(), $this->getSendingQueueWorker(),
[ [
@@ -335,14 +326,14 @@ class SendingQueueTest extends \MailPoetTest {
$this->entityManager $this->entityManager
); );
$sendingQueueWorker->sendNewsletters( $sendingQueueWorker->sendNewsletters(
$this->scheduledTaskEntity, $this->scheduledTask,
$preparedSubscribers = [], $preparedSubscribers = [],
$preparedNewsletters = [], $preparedNewsletters = [],
$preparedSubscribers = [], $preparedSubscribers = [],
$statistics[] = [ $statistics[] = [
'newsletter_id' => 1, 'newsletter_id' => 1,
'subscriber_id' => 1, 'subscriber_id' => 1,
'queue_id' => $queue->id, 'queue_id' => $this->sendingQueue->getId(),
], ],
microtime(true) microtime(true)
); );
@@ -381,7 +372,7 @@ class SendingQueueTest extends \MailPoetTest {
public function testItDeletesQueueWhenNewsletterIsNotFound() { public function testItDeletesQueueWhenNewsletterIsNotFound() {
// queue exists // queue exists
$queue = SendingQueue::findOne($this->queue->id); $queue = SendingQueue::findOne($this->sendingQueue->getId());
verify($queue)->notEquals(false); verify($queue)->notEquals(false);
// delete newsletter // delete newsletter
@@ -389,7 +380,7 @@ class SendingQueueTest extends \MailPoetTest {
// queue no longer exists // queue no longer exists
$this->sendingQueueWorker->process(); $this->sendingQueueWorker->process();
$queue = SendingQueue::findOne($this->queue->id); $queue = SendingQueue::findOne($this->sendingQueue->getId());
verify($queue)->false(); verify($queue)->false();
} }
@@ -470,7 +461,7 @@ class SendingQueueTest extends \MailPoetTest {
verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT); verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT);
// queue status is set to completed // queue status is set to completed
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -490,7 +481,7 @@ class SendingQueueTest extends \MailPoetTest {
// statistics entry should be created // statistics entry should be created
$statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id) $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
->where('subscriber_id', $this->subscriber->getId()) ->where('subscriber_id', $this->subscriber->getId())
->where('queue_id', $this->queue->id) ->where('queue_id', $this->sendingQueue->getId())
->findOne(); ->findOne();
verify($statistics)->notEquals(false); verify($statistics)->notEquals(false);
} }
@@ -504,37 +495,20 @@ class SendingQueueTest extends \MailPoetTest {
$subscriber1->setEmail('1@localhost.com'); $subscriber1->setEmail('1@localhost.com');
$subscribersRepository->persist($subscriber1); $subscribersRepository->persist($subscriber1);
$subscriber2 = $this->createSubscriber('2@lcoalhost.com', 'first', 'last'); $subscriber2 = $this->createSubscriber('2@lcoalhost.com', 'first', 'last');
$subscriber2->setStatus(SubscriberEntity::STATUS_SUBSCRIBED); $subscriber2->setStatus(SubscriberEntity::STATUS_SUBSCRIBED);
$subscriber2->setSource('form'); $subscriber2->setSource('form');
$subscriber2->setEmail('2@localhost.com'); $subscriber2->setEmail('2@localhost.com');
$subscribersRepository->persist($subscriber2); $subscribersRepository->persist($subscriber2);
$subscribersRepository->flush(); $sendingQueue = $this->createQueueWithTask($this->newsletterEntity);
$subscribers = [ $sendingQueue->setNewsletterRenderedBody(['html' => '<p>Hello [subscriber:email]</p>', 'text' => 'Hello [subscriber:email]']);
$subscriber1, $sendingQueue->setNewsletterRenderedSubject('News for [subscriber:email]');
$subscriber2, $scheduledTask = $sendingQueue->getTask();
]; $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
$this->scheduledTaskSubscribersRepository->setSubscribers($scheduledTask, [$subscriber1->getId(), $subscriber2->getId()]);
$subscriberIds = array_map(
function(SubscriberEntity $item): int {
return (int)$item->getId();
},
$subscribers
);
$queue = SendingTask::create();
$queue->newsletterRenderedBody = ['html' => '<p>Hello [subscriber:email]</p>', 'text' => 'Hello [subscriber:email]'];
$queue->newsletterRenderedSubject = 'News for [subscriber:email]';
$queue->setSubscribers($subscriberIds);
$queue->save();
$scheduledTaskEntity = $this->scheduledTasksRepository->findOneById($queue->taskId);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTaskEntity);
$queueEntity = $scheduledTaskEntity->getSendingQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queueEntity);
$this->entityManager->refresh($queueEntity);
$this->settings->set('tracking.level', TrackingConfig::LEVEL_BASIC); $this->settings->set('tracking.level', TrackingConfig::LEVEL_BASIC);
$newsletter = $this->newsletter; $newsletter = $this->newsletter;
@@ -548,11 +522,11 @@ class SendingQueueTest extends \MailPoetTest {
return $subscriber->get('email'); return $subscriber->get('email');
}, },
'getProcessingMethod' => 'individual', 'getProcessingMethod' => 'individual',
'send' => Expected::exactly(2, function($newsletter, $subscriberEmail, $extraParams) use ($subscribersRepository, $queue) { 'send' => Expected::exactly(2, function($newsletter, $subscriberEmail, $extraParams) use ($subscribersRepository, $sendingQueue) {
$subscriber = $subscribersRepository->findOneBy(['email' => $subscriberEmail]); $subscriber = $subscribersRepository->findOneBy(['email' => $subscriberEmail]);
$subscriptionUrlFactory = SubscriptionUrlFactory::getInstance(); $subscriptionUrlFactory = SubscriptionUrlFactory::getInstance();
$unsubscribeUrl = $subscriptionUrlFactory->getUnsubscribeUrl($subscriber, (int)$queue->id); $unsubscribeUrl = $subscriptionUrlFactory->getUnsubscribeUrl($subscriber, (int)$sendingQueue->getId());
verify($newsletter['subject'])->equals('News for ' . $subscriberEmail); verify($newsletter['subject'])->equals('News for ' . $subscriberEmail);
verify($newsletter['body']['html'])->equals('<p>Hello ' . $subscriberEmail . '</p>'); verify($newsletter['body']['html'])->equals('<p>Hello ' . $subscriberEmail . '</p>');
verify($newsletter['body']['text'])->equals('Hello ' . $subscriberEmail); verify($newsletter['body']['text'])->equals('Hello ' . $subscriberEmail);
@@ -572,7 +546,7 @@ class SendingQueueTest extends \MailPoetTest {
Subscriber::findOne($subscriber2->getId()), Subscriber::findOne($subscriber2->getId()),
]; ];
$sendingQueueWorker->processQueue($scheduledTaskEntity, $newsletter, $subscribersModels, $timer); $sendingQueueWorker->processQueue($scheduledTask, $newsletter, $subscribersModels, $timer);
} }
public function testItCanProcessSubscribersInBulk() { public function testItCanProcessSubscribersInBulk() {
@@ -604,7 +578,7 @@ class SendingQueueTest extends \MailPoetTest {
verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT); verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT);
// queue status is set to completed // queue status is set to completed
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -624,7 +598,7 @@ class SendingQueueTest extends \MailPoetTest {
// statistics entry should be created // statistics entry should be created
$statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id) $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
->where('subscriber_id', $this->subscriber->getId()) ->where('subscriber_id', $this->subscriber->getId())
->where('queue_id', $this->queue->id) ->where('queue_id', $this->sendingQueue->getId())
->findOne(); ->findOne();
verify($statistics)->notEquals(false); verify($statistics)->notEquals(false);
} }
@@ -647,7 +621,7 @@ class SendingQueueTest extends \MailPoetTest {
$sendingQueueWorker->process(); $sendingQueueWorker->process();
// queue status is set to completed // queue status is set to completed
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -673,21 +647,20 @@ class SendingQueueTest extends \MailPoetTest {
// statistics entry should be created // statistics entry should be created
$statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id) $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
->where('subscriber_id', $this->subscriber->getId()) ->where('subscriber_id', $this->subscriber->getId())
->where('queue_id', $this->queue->id) ->where('queue_id', $this->sendingQueue->getId())
->findOne(); ->findOne();
verify($statistics)->notEquals(false); verify($statistics)->notEquals(false);
} }
public function testItHandlesSendingErrorCorrectly() { public function testItHandlesSendingErrorCorrectly() {
$wrongSubscriber = $this->createSubscriber('doe@john.com>', 'Doe', 'John'); $wrongSubscriber = $this->createSubscriber('doe@john.com>', 'Doe', 'John');
$queue = SendingTask::create();
$queue->newsletterId = $this->newsletter->id; $sendingQueue = $this->createQueueWithTask($this->newsletterEntity);
$queue->setSubscribers([ $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$this->subscriber->getId(), $scheduledTask = $sendingQueue->getTask();
$wrongSubscriber->getId(), $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
]); $this->scheduledTaskSubscribersRepository->setSubscribers($scheduledTask, [$this->subscriber->getId(), $wrongSubscriber->getId()]);
$queue->countTotal = 2;
$queue->save();
// Error that simulates sending error from the bridge // Error that simulates sending error from the bridge
$mailerError = new MailerError( $mailerError = new MailerError(
MailerError::OPERATION_SEND, MailerError::OPERATION_SEND,
@@ -723,17 +696,12 @@ class SendingQueueTest extends \MailPoetTest {
$this->entityManager $this->entityManager
); );
$sendingQueue = $this->sendingQueuesRepository->findOneById($queue->id);
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
$sendingQueueWorker->sendNewsletters( $sendingQueueWorker->sendNewsletters(
$scheduledTask, $scheduledTask,
[$this->subscriber->getId(), $wrongSubscriber->getId()], [$this->subscriber->getId(), $wrongSubscriber->getId()],
[], [],
[$this->subscriber->getEmail(), $wrongSubscriber->getEmail()], [$this->subscriber->getEmail(), $wrongSubscriber->getEmail()],
['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $queue->id], ['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $sendingQueue->getId()],
microtime(true) microtime(true)
); );
@@ -751,7 +719,7 @@ class SendingQueueTest extends \MailPoetTest {
[$this->subscriber->getId()], [$this->subscriber->getId()],
[], [],
[$this->subscriber->getEmail()], [$this->subscriber->getEmail()],
['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $queue->id], ['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $sendingQueue->getId()],
microtime(true) microtime(true)
); );
@@ -766,11 +734,8 @@ class SendingQueueTest extends \MailPoetTest {
} }
public function testItUpdatesUpdateTime() { public function testItUpdatesUpdateTime() {
$originalUpdated = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->subHours(5)->toDateTimeString(); $originalUpdated = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->subHours(5);
$this->setUpdatedAtForEntity($this->scheduledTask, $originalUpdated);
$this->queue->scheduled_at = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$this->queue->updated_at = $originalUpdated;
$this->queue->save();
$this->newsletter->type = NewsletterEntity::TYPE_WELCOME; $this->newsletter->type = NewsletterEntity::TYPE_WELCOME;
$this->newsletterSegment->delete(); $this->newsletterSegment->delete();
@@ -780,9 +745,7 @@ class SendingQueueTest extends \MailPoetTest {
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$newScheduledTask = $this->scheduledTasksRepository->findOneById($this->queue->task_id); verify($this->scheduledTask->getUpdatedAt())->notEquals($originalUpdated);
$this->assertInstanceOf(ScheduledTaskEntity::class, $newScheduledTask);
verify($newScheduledTask->getUpdatedAt())->notEquals($originalUpdated);
} }
public function testItCanProcessWelcomeNewsletters() { public function testItCanProcessWelcomeNewsletters() {
@@ -812,7 +775,7 @@ class SendingQueueTest extends \MailPoetTest {
verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT); verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT);
// queue status is set to completed // queue status is set to completed
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -832,7 +795,7 @@ class SendingQueueTest extends \MailPoetTest {
// statistics entry should be created // statistics entry should be created
$statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id) $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
->where('subscriber_id', $this->subscriber->getId()) ->where('subscriber_id', $this->subscriber->getId())
->where('queue_id', $this->queue->id) ->where('queue_id', $this->sendingQueue->getId())
->findOne(); ->findOne();
verify($statistics)->notEquals(false); verify($statistics)->notEquals(false);
} }
@@ -842,7 +805,6 @@ class SendingQueueTest extends \MailPoetTest {
$this->subscriber->setStatus(SubscriberEntity::STATUS_UNSUBSCRIBED); $this->subscriber->setStatus(SubscriberEntity::STATUS_UNSUBSCRIBED);
$this->entityManager->flush(); $this->entityManager->flush();
$this->newsletterSegment->delete(); $this->newsletterSegment->delete();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker = $this->getSendingQueueWorker( $sendingQueueWorker = $this->getSendingQueueWorker(
$this->construct( $this->construct(
@@ -856,7 +818,7 @@ class SendingQueueTest extends \MailPoetTest {
$sendingQueueWorker->process(); $sendingQueueWorker->process();
// queue status is set to completed // queue status is set to completed
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -875,11 +837,12 @@ class SendingQueueTest extends \MailPoetTest {
$unsubscribedSubscriber = $subscriberFactory $unsubscribedSubscriber = $subscriberFactory
->withStatus(SubscriberEntity::STATUS_UNSUBSCRIBED) ->withStatus(SubscriberEntity::STATUS_UNSUBSCRIBED)
->create(); ->create();
$this->queue->setSubscribers([
$this->subscriber->getId(), // subscriber that should be processed $this->scheduledTaskSubscribersRepository->setSubscribers(
$unsubscribedSubscriber->getId(), // subscriber that should be skipped $this->scheduledTask,
]); [$this->subscriber->getId(), $unsubscribedSubscriber->getId()]
$this->entityManager->refresh($this->sendingQueueEntity); );
$sendingQueueWorker = $this->getSendingQueueWorker( $sendingQueueWorker = $this->getSendingQueueWorker(
$this->construct( $this->construct(
MailerTask::class, MailerTask::class,
@@ -894,7 +857,7 @@ class SendingQueueTest extends \MailPoetTest {
$sendingQueueWorker->process(); $sendingQueueWorker->process();
// queue status is set to completed // queue status is set to completed
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -909,15 +872,14 @@ class SendingQueueTest extends \MailPoetTest {
verify($sendingQueue->getCountToProcess())->equals(0); verify($sendingQueue->getCountToProcess())->equals(0);
} }
public function testItRemovesNonexistentSubscribersFromProcessingList() { public function testItRemovesSubscribersFromProcessingListWhenNewsletterHasSegmentAndSubscriberIsNotPartOfIt() {
$queue = $this->queue; $subscriberNotPartOfNewsletterSegment = $this->createSubscriber('subscriber1@mailpoet.com', 'Subscriber', 'One');
$queue->setSubscribers([
$this->subscriber->getId(), $this->scheduledTaskSubscribersRepository->setSubscribers(
1234564545, $this->scheduledTask,
]); [$this->subscriber->getId(), $subscriberNotPartOfNewsletterSegment->getId()]
$queue->countTotal = 2; );
$queue->save();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker = $this->sendingQueueWorker; $sendingQueueWorker = $this->sendingQueueWorker;
$sendingQueueWorker->mailerTask = $this->construct( $sendingQueueWorker->mailerTask = $this->construct(
MailerTask::class, MailerTask::class,
@@ -930,20 +892,14 @@ class SendingQueueTest extends \MailPoetTest {
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($queue->id);
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
$this->sendingQueuesRepository->refresh($sendingQueue);
$this->scheduledTasksRepository->refresh($scheduledTask);
// queue subscriber processed/to process count is updated // queue subscriber processed/to process count is updated
verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED)) verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED))
->equals([]); ->equals([]);
verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED)) verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED))
->equals([$this->subscriber]); ->equals([$this->subscriber]);
verify($sendingQueue->getCountTotal())->equals(1); verify($this->sendingQueue->getCountTotal())->equals(1);
verify($sendingQueue->getCountProcessed())->equals(1); verify($this->sendingQueue->getCountProcessed())->equals(1);
verify($sendingQueue->getCountToProcess())->equals(0); verify($this->sendingQueue->getCountToProcess())->equals(0);
// statistics entry should be created only for 1 subscriber // statistics entry should be created only for 1 subscriber
$statistics = StatisticsNewsletters::findMany(); $statistics = StatisticsNewsletters::findMany();
@@ -951,16 +907,17 @@ class SendingQueueTest extends \MailPoetTest {
} }
public function testItDoesNotCallMailerWithEmptyBatch() { public function testItDoesNotCallMailerWithEmptyBatch() {
$queue = $this->queue;
$subscribers = []; $subscribers = [];
while (count($subscribers) < 2 * SendingThrottlingHandler::BATCH_SIZE) { while (count($subscribers) < 2 * SendingThrottlingHandler::BATCH_SIZE) {
$subscribers[] = 1234564545 + count($subscribers); $subscribers[] = 1234564545 + count($subscribers);
} }
$subscribers[] = $this->subscriber->getId(); $subscribers[] = $this->subscriber->getId();
$queue->setSubscribers($subscribers);
$queue->countTotal = count($subscribers); $this->scheduledTaskSubscribersRepository->setSubscribers($this->scheduledTask, $subscribers);
$queue->save(); $this->sendingQueue->setCountTotal(count($subscribers));
$this->entityManager->refresh($this->sendingQueueEntity); $this->entityManager->persist($this->sendingQueue);
$this->entityManager->flush();
$sendingQueueWorker = $this->sendingQueueWorker; $sendingQueueWorker = $this->sendingQueueWorker;
$sendingQueueWorker->mailerTask = $this->construct( $sendingQueueWorker->mailerTask = $this->construct(
MailerTask::class, MailerTask::class,
@@ -973,7 +930,7 @@ class SendingQueueTest extends \MailPoetTest {
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue); $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask); $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -990,14 +947,11 @@ class SendingQueueTest extends \MailPoetTest {
} }
public function testItUpdatesQueueSubscriberCountWhenNoneOfSubscribersExist() { public function testItUpdatesQueueSubscriberCountWhenNoneOfSubscribersExist() {
$queue = $this->queue; $this->scheduledTaskSubscribersRepository->setSubscribers($this->scheduledTask, [123, 456,]);
$queue->setSubscribers([ $this->sendingQueue->setCountTotal(2);
123, $this->entityManager->persist($this->sendingQueue);
456, $this->entityManager->flush();
]);
$queue->countTotal = 2;
$queue->save();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker = $this->sendingQueueWorker; $sendingQueueWorker = $this->sendingQueueWorker;
$sendingQueueWorker->mailerTask = $this->construct( $sendingQueueWorker->mailerTask = $this->construct(
MailerTask::class, MailerTask::class,
@@ -1006,20 +960,14 @@ class SendingQueueTest extends \MailPoetTest {
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
$this->sendingQueuesRepository->refresh($sendingQueue);
$this->scheduledTasksRepository->refresh($scheduledTask);
// queue subscriber processed/to process count is updated // queue subscriber processed/to process count is updated
verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED)) verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED))
->equals([]); ->equals([]);
verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED)) verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED))
->equals([]); ->equals([]);
verify($sendingQueue->getCountTotal())->equals(0); verify($this->sendingQueue->getCountTotal())->equals(0);
verify($sendingQueue->getCountProcessed())->equals(0); verify($this->sendingQueue->getCountProcessed())->equals(0);
verify($sendingQueue->getCountToProcess())->equals(0); verify($this->sendingQueue->getCountToProcess())->equals(0);
} }
public function testItDoesNotSendToTrashedSubscribers() { public function testItDoesNotSendToTrashedSubscribers() {
@@ -1034,10 +982,9 @@ class SendingQueueTest extends \MailPoetTest {
$subscriber = $this->subscriber; $subscriber = $this->subscriber;
$subscriber->setDeletedAt(Carbon::now()); $subscriber->setDeletedAt(Carbon::now());
$this->entityManager->flush(); $this->entityManager->flush();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$this->sendingQueuesRepository->refresh($sendingQueue); $this->sendingQueuesRepository->refresh($sendingQueue);
verify($sendingQueue->getCountTotal())->equals(0); verify($sendingQueue->getCountTotal())->equals(0);
@@ -1061,10 +1008,9 @@ class SendingQueueTest extends \MailPoetTest {
$subscriber = $this->subscriber; $subscriber = $this->subscriber;
$subscriber->setStatus($subscriberStatus); $subscriber->setStatus($subscriberStatus);
$this->entityManager->flush(); $this->entityManager->flush();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$this->sendingQueuesRepository->refresh($sendingQueue); $this->sendingQueuesRepository->refresh($sendingQueue);
verify($sendingQueue->getCountTotal())->equals($expectSending ? 1 : 0); verify($sendingQueue->getCountTotal())->equals($expectSending ? 1 : 0);
@@ -1095,10 +1041,9 @@ class SendingQueueTest extends \MailPoetTest {
$subscriber = $this->subscriber; $subscriber = $this->subscriber;
$subscriber->setStatus(SubscriberEntity::STATUS_UNSUBSCRIBED); $subscriber->setStatus(SubscriberEntity::STATUS_UNSUBSCRIBED);
$this->entityManager->flush(); $this->entityManager->flush();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$this->sendingQueuesRepository->refresh($sendingQueue); $this->sendingQueuesRepository->refresh($sendingQueue);
verify($sendingQueue->getCountTotal())->equals(0); verify($sendingQueue->getCountTotal())->equals(0);
@@ -1116,10 +1061,9 @@ class SendingQueueTest extends \MailPoetTest {
$subscriberSegment = $this->subscriberSegment; $subscriberSegment = $this->subscriberSegment;
$subscriberSegment->status = SubscriberEntity::STATUS_UNSUBSCRIBED; $subscriberSegment->status = SubscriberEntity::STATUS_UNSUBSCRIBED;
$subscriberSegment->save(); $subscriberSegment->save();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$this->sendingQueuesRepository->refresh($sendingQueue); $this->sendingQueuesRepository->refresh($sendingQueue);
verify($sendingQueue->getCountTotal())->equals(0); verify($sendingQueue->getCountTotal())->equals(0);
@@ -1137,10 +1081,9 @@ class SendingQueueTest extends \MailPoetTest {
$subscriber = $this->subscriber; $subscriber = $this->subscriber;
$subscriber->setStatus(SubscriberEntity::STATUS_INACTIVE); $subscriber->setStatus(SubscriberEntity::STATUS_INACTIVE);
$this->entityManager->flush(); $this->entityManager->flush();
$this->entityManager->refresh($this->sendingQueueEntity);
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id); $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue); $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
$this->sendingQueuesRepository->refresh($sendingQueue); $this->sendingQueuesRepository->refresh($sendingQueue);
verify($sendingQueue->getCountTotal())->equals(0); verify($sendingQueue->getCountTotal())->equals(0);
@@ -1180,7 +1123,7 @@ class SendingQueueTest extends \MailPoetTest {
); );
try { try {
$sendingQueueWorker->sendNewsletters( $sendingQueueWorker->sendNewsletters(
$this->scheduledTaskEntity, $this->scheduledTask,
$preparedSubscribers = [], $preparedSubscribers = [],
$preparedNewsletters = [], $preparedNewsletters = [],
$preparedSubscribers = [], $preparedSubscribers = [],
@@ -1196,7 +1139,7 @@ class SendingQueueTest extends \MailPoetTest {
verify($mailerLog['error'])->equals( verify($mailerLog['error'])->equals(
[ [
'operation' => 'processed_list_update', 'operation' => 'processed_list_update',
'error_message' => "QUEUE-{$this->sendingQueueEntity->getId()}-PROCESSED-LIST-UPDATE", 'error_message' => "QUEUE-{$this->sendingQueue->getId()}-PROCESSED-LIST-UPDATE",
] ]
); );
} }
@@ -1325,7 +1268,7 @@ class SendingQueueTest extends \MailPoetTest {
) )
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$meta = $this->queue->getSendingQueueEntity()->getMeta(); $meta = $this->sendingQueue->getMeta();
verify(isset($meta['campaignId']))->true(); verify(isset($meta['campaignId']))->true();
$campaignId = $meta['campaignId']; $campaignId = $meta['campaignId'];
verify(strlen($campaignId))->equals(16); verify(strlen($campaignId))->equals(16);
@@ -1349,7 +1292,7 @@ class SendingQueueTest extends \MailPoetTest {
) )
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$meta = $this->queue->getSendingQueueEntity()->getMeta(); $meta = $this->sendingQueue->getMeta();
verify(isset($meta['campaignId']))->true(); verify(isset($meta['campaignId']))->true();
$campaignId = $meta['campaignId']; $campaignId = $meta['campaignId'];
verify($mailerTaskExtraParams['meta']['campaign_id'])->equals($campaignId); verify($mailerTaskExtraParams['meta']['campaign_id'])->equals($campaignId);
@@ -1363,9 +1306,10 @@ class SendingQueueTest extends \MailPoetTest {
$segment2->subscriberId = (int)$secondSubscriber->getId(); $segment2->subscriberId = (int)$secondSubscriber->getId();
$segment2->segmentId = (int)$this->segment->id; $segment2->segmentId = (int)$this->segment->id;
$segment2->save(); $segment2->save();
$this->queue->setSubscribers([$this->subscriber->getId(), $secondSubscriber->getId()]); $this->scheduledTaskSubscribersRepository->setSubscribers(
$this->queue->countTotal = 2; $this->scheduledTask,
$this->queue->save(); [$this->subscriber->getId(), $secondSubscriber->getId()]
);
$sendingQueueWorker = $this->getSendingQueueWorker( $sendingQueueWorker = $this->getSendingQueueWorker(
$this->construct( $this->construct(
MailerTask::class, MailerTask::class,
@@ -1382,7 +1326,7 @@ class SendingQueueTest extends \MailPoetTest {
) )
); );
$sendingQueueWorker->process(); $sendingQueueWorker->process();
$meta = $this->queue->getSendingQueueEntity()->getMeta(); $meta = $this->sendingQueue->getMeta();
verify(isset($meta['campaignId']))->true(); verify(isset($meta['campaignId']))->true();
$campaignId = $meta['campaignId']; $campaignId = $meta['campaignId'];
verify(count($mailerTaskCampaignIds))->equals(2); verify(count($mailerTaskCampaignIds))->equals(2);