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

Replace Newsletter model with NewsletterEntity in SchedulerTest

Browse Source 
Temporary code was added to Scheduler to make some of its methods work
both with a Newsletter model and a NewsletterEntity.

[MAILPOET-4370]
This commit is contained in:
Rodrigo Primo
2023-05-17 17:28:28 -03:00
committed by Aschepikov
parent c73bb345a8
commit ca3b5032ca
2 changed files with 137 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
mailpoet/lib/Cron/Workers/Scheduler.php
View File

@@ -135,6 +135,10 @@ class Scheduler {
} }
public function processWelcomeNewsletter($newsletter, $queue) { public function processWelcomeNewsletter($newsletter, $queue) {
if ($newsletter instanceof NewsletterEntity) {
$newsletter = Newsletter::filter('filterWithOptions', $newsletter->getType())->findOne($newsletter->getId());
}
$subscribers = $queue->getSubscribers(); $subscribers = $queue->getSubscribers();
if (empty($subscribers[0])) { if (empty($subscribers[0])) {
$queue->delete(); $queue->delete();
@@ -160,6 +164,10 @@ class Scheduler {
} }
public function processPostNotificationNewsletter($newsletter, SendingTask $queue) { public function processPostNotificationNewsletter($newsletter, SendingTask $queue) {
if ($newsletter instanceof NewsletterEntity) {
$newsletter = Newsletter::filter('filterWithOptions', $newsletter->getType())->findOne($newsletter->getId());
}
$this->loggerFactory->getLogger(LoggerFactory::TOPIC_POST_NOTIFICATIONS)->info( $this->loggerFactory->getLogger(LoggerFactory::TOPIC_POST_NOTIFICATIONS)->info(
'process post notification in scheduler', 'process post notification in scheduler',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->taskId] ['newsletter_id' => $newsletter->id, 'task_id' => $queue->taskId]
@@ -301,6 +309,10 @@ class Scheduler {
} }
public function processScheduledStandardNewsletter($newsletter, SendingTask $task) { public function processScheduledStandardNewsletter($newsletter, SendingTask $task) {
if ($newsletter instanceof NewsletterEntity) {
$newsletter = Newsletter::filter('filterWithOptions', $newsletter->getType())->findOne($newsletter->getId());
}
$newsletterEntity = $this->newslettersRepository->findOneById($newsletter->id); $newsletterEntity = $this->newslettersRepository->findOneById($newsletter->id);
$taskEntity = null; $taskEntity = null;
@@ -333,6 +345,10 @@ class Scheduler {
} }
public function verifyMailpoetSubscriber($subscriberId, $newsletter, $queue) { public function verifyMailpoetSubscriber($subscriberId, $newsletter, $queue) {
if ($newsletter instanceof NewsletterEntity) {
$newsletter = Newsletter::filter('filterWithOptions', $newsletter->getType())->findOne($newsletter->getId());
}
$subscriber = Subscriber::findOne($subscriberId); $subscriber = Subscriber::findOne($subscriberId);
// check if subscriber is in proper segment // check if subscriber is in proper segment
$subscriberInSegment = $subscriberInSegment =
@@ -348,6 +364,10 @@ class Scheduler {
} }
public function verifyWPSubscriber($subscriberId, $newsletter, $queue) { public function verifyWPSubscriber($subscriberId, $newsletter, $queue) {
if ($newsletter instanceof NewsletterEntity) {
$newsletter = Newsletter::filter('filterWithOptions', $newsletter->getType())->findOne($newsletter->getId());
}
// check if user has the proper role // check if user has the proper role
$subscriber = Subscriber::findOne($subscriberId); $subscriber = Subscriber::findOne($subscriberId);
if (!$subscriber || $subscriber->isWPUser() === false) { if (!$subscriber || $subscriber->isWPUser() === false) {
@@ -391,6 +411,10 @@ class Scheduler {
} }
public function deleteQueueOrUpdateNextRunDate($queue, $newsletter) { public function deleteQueueOrUpdateNextRunDate($queue, $newsletter) {
if ($newsletter instanceof NewsletterEntity) {
$newsletter = Newsletter::filter('filterWithOptions', $newsletter->getType())->findOne($newsletter->getId());
}
if ($newsletter->intervalType === PostNotificationScheduler::INTERVAL_IMMEDIATELY) { if ($newsletter->intervalType === PostNotificationScheduler::INTERVAL_IMMEDIATELY) {
$queue->delete(); $queue->delete();
$this->updateScheduledTaskEntity($queue, true); $this->updateScheduledTaskEntity($queue, true);

267
mailpoet/tests/integration/Cron/Workers/SchedulerTest.php
View File

@@ -8,6 +8,7 @@ use MailPoet\Cron\CronHelper;
use MailPoet\Cron\CronWorkerScheduler; use MailPoet\Cron\CronWorkerScheduler;
use MailPoet\Cron\Workers\Scheduler; use MailPoet\Cron\Workers\Scheduler;
use MailPoet\Entities\NewsletterEntity; use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\NewsletterSegmentEntity; use MailPoet\Entities\NewsletterSegmentEntity;
use MailPoet\Entities\ScheduledTaskEntity; use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity; use MailPoet\Entities\ScheduledTaskSubscriberEntity;
@@ -16,7 +17,6 @@ use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity; use MailPoet\Entities\SubscriberEntity;
use MailPoet\Entities\SubscriberSegmentEntity; use MailPoet\Entities\SubscriberSegmentEntity;
use MailPoet\Logging\LoggerFactory; use MailPoet\Logging\LoggerFactory;
use MailPoet\Models\Newsletter;
use MailPoet\Newsletter\NewslettersRepository; use MailPoet\Newsletter\NewslettersRepository;
use MailPoet\Newsletter\Scheduler\Scheduler as NewsletterScheduler; use MailPoet\Newsletter\Scheduler\Scheduler as NewsletterScheduler;
use MailPoet\Newsletter\Scheduler\WelcomeScheduler; use MailPoet\Newsletter\Scheduler\WelcomeScheduler;
@@ -88,6 +88,9 @@ class SchedulerTest extends \MailPoetTest {
/** @var ScheduledTaskFactory */ /** @var ScheduledTaskFactory */
private $scheduledTaskFactory; private $scheduledTaskFactory;
/** @var NewsletterFactory */
private $newsletterFactory;
public function _before() { public function _before() {
parent::_before(); parent::_before();
$this->loggerFactory = LoggerFactory::getInstance(); $this->loggerFactory = LoggerFactory::getInstance();
@@ -107,6 +110,7 @@ class SchedulerTest extends \MailPoetTest {
$this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class); $this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class);
$this->segmentFactory = new SegmentFactory(); $this->segmentFactory = new SegmentFactory();
$this->scheduledTaskFactory = new ScheduledTaskFactory(); $this->scheduledTaskFactory = new ScheduledTaskFactory();
$this->newsletterFactory = new NewsletterFactory();
} }
public function testItThrowsExceptionWhenExecutionLimitIsReached() { public function testItThrowsExceptionWhenExecutionLimitIsReached() {
@@ -137,7 +141,7 @@ class SchedulerTest extends \MailPoetTest {
$segments[] = $this->segmentFactory $segments[] = $this->segmentFactory
->withName('Segment B') ->withName('Segment B')
->create(); ->create();
$newsletter = (new NewsletterFactory()) $newsletter = $this->newsletterFactory
->withType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY) ->withType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY)
->withSegments($segments) ->withSegments($segments)
->create(); ->create();
@@ -165,14 +169,13 @@ class SchedulerTest extends \MailPoetTest {
public function testItCanDeleteQueueWhenDeliveryIsSetToImmediately() { public function testItCanDeleteQueueWhenDeliveryIsSetToImmediately() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'intervalType', 'immediately'); $this->newsletterOptionFactory->create($newsletterEntity, 'intervalType', 'immediately');
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME) $newsletter = $this->newslettersRepository->findOneById($newsletter->getId());
->findOne($newsletter->id); $this->assertInstanceOf(NewsletterEntity::class, $newsletter);
$this->assertInstanceOf(Newsletter::class, $newsletter); $queue = $this->_createQueue($newsletter->getId());
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// queue and associated newsletter should be deleted when interval type is set to "immediately" // queue and associated newsletter should be deleted when interval type is set to "immediately"
@@ -183,27 +186,27 @@ class SchedulerTest extends \MailPoetTest {
public function testItCanRescheduleQueueDeliveryTime() { public function testItCanRescheduleQueueDeliveryTime() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$this->assertInstanceOf(Newsletter::class, $newsletter); $this->assertInstanceOf(NewsletterEntity::class, $newsletter);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $newsletterOption = $this->newsletterOptionFactory->create($newsletter, 'intervalType', 'daily');
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterOption = $this->newsletterOptionFactory->create($newsletterEntity, 'intervalType', 'daily');
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME) $newsletter = $this->newslettersRepository->findOneById($newsletter->getId());
->findOne($newsletter->id); $this->assertInstanceOf(NewsletterEntity::class, $newsletter);
$this->assertInstanceOf(Newsletter::class, $newsletter); $queue = $this->_createQueue($newsletter->getId());
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// queue's next run date should change when interval type is set to anything // queue's next run date should change when interval type is set to anything
// other than "immediately" // other than "immediately"
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$newsletterOption->setValue('daily'); $newsletterOption->setValue('daily');
$this->entityManager->persist($newsletterOption); $this->entityManager->persist($newsletterOption);
$this->entityManager->flush(); $this->entityManager->flush();
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME)->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter); $newsletter = $this->newslettersRepository->findOneById($newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
expect($queue->scheduledAt)->null(); expect($queue->scheduledAt)->null();
$newsletter->schedule = '0 5 * * *'; // set it to daily at 5
$this->newsletterOptionFactory->create($newsletter, NewsletterOptionFieldEntity::NAME_SCHEDULE, '0 5 * * *');
$scheduler->deleteQueueOrUpdateNextRunDate($queue, $newsletter); $scheduler->deleteQueueOrUpdateNextRunDate($queue, $newsletter);
$queueEntity = $this->sendingQueuesRepository->findOneById($queue->id); $queueEntity = $this->sendingQueuesRepository->findOneById($queue->id);
@@ -218,14 +221,9 @@ class SchedulerTest extends \MailPoetTest {
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $this->newsletterOptionFactory->create($newsletter, 'role', 'author');
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', 'author');
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME) $queue = $this->_createQueue($newsletter->getId());
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return false and delete queue when subscriber is not a WP user // return false and delete queue when subscriber is not a WP user
@@ -239,14 +237,9 @@ class SchedulerTest extends \MailPoetTest {
$subscriber = $this->_createSubscriber($wPUser->ID); $subscriber = $this->_createSubscriber($wPUser->ID);
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $this->newsletterOptionFactory->create($newsletter, 'role', 'author');
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', 'author');
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME) $queue = $this->_createQueue($newsletter->getId());
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return false and delete queue when subscriber role is different from the one // return false and delete queue when subscriber role is different from the one
@@ -261,14 +254,9 @@ class SchedulerTest extends \MailPoetTest {
$subscriber = $this->_createSubscriber($wPUser->ID); $subscriber = $this->_createSubscriber($wPUser->ID);
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $this->newsletterOptionFactory->create($newsletter, 'role', 'author');
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', 'author');
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME) $queue = $this->_createQueue($newsletter->getId());
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return true when user exists and WP role matches the one specified for the welcome email // return true when user exists and WP role matches the one specified for the welcome email
@@ -282,14 +270,9 @@ class SchedulerTest extends \MailPoetTest {
$subscriber = $this->_createSubscriber($wPUser->ID); $subscriber = $this->_createSubscriber($wPUser->ID);
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $this->newsletterOptionFactory->create($newsletter, 'role', WelcomeScheduler::WORDPRESS_ALL_ROLES);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', WelcomeScheduler::WORDPRESS_ALL_ROLES);
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_WELCOME) $queue = $this->_createQueue($newsletter->getId());
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// true when user exists and has any role // true when user exists and has any role
@@ -300,7 +283,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItDoesNotProcessWelcomeNewsletterWhenThereAreNoSubscribersToProcess() { public function testItDoesNotProcessWelcomeNewsletterWhenThereAreNoSubscribersToProcess() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->setSubscribers([]); $queue->setSubscribers([]);
// delete queue when the list of subscribers to process is blank // delete queue when the list of subscribers to process is blank
@@ -312,8 +295,9 @@ class SchedulerTest extends \MailPoetTest {
public function testItDoesNotProcessWelcomeNewsletterWhenWPUserCannotBeVerified() { public function testItDoesNotProcessWelcomeNewsletterWhenWPUserCannotBeVerified() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletter->event = 'user'; $this->newsletterOptionFactory->create($newsletter, 'event', 'user');
$queue = $this->_createQueue($newsletter->id);
$queue = $this->_createQueue($newsletter->getId());
$queue->setSubscribers([1]); $queue->setSubscribers([1]);
// return false when WP user cannot be verified // return false when WP user cannot be verified
@@ -327,8 +311,8 @@ class SchedulerTest extends \MailPoetTest {
public function testItDoesNotProcessWelcomeNewsletterWhenSubscriberCannotBeVerified() { public function testItDoesNotProcessWelcomeNewsletterWhenSubscriberCannotBeVerified() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletter->event = 'segment'; $this->newsletterOptionFactory->create($newsletter, 'event', 'segment');
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->setSubscribers([1]); $queue->setSubscribers([1]);
// return false when subscriber cannot be verified // return false when subscriber cannot be verified
@@ -342,10 +326,10 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesWelcomeNewsletterWhenSubscriberIsVerified() { public function testItProcessesWelcomeNewsletterWhenSubscriberIsVerified() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletter->event = 'segment'; $this->newsletterOptionFactory->create($newsletter, 'event', 'segment');
// return true when subsriber is verified and update the queue's status to null // return true when subsriber is verified and update the queue's status to null
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->setSubscribers([1]); $queue->setSubscribers([1]);
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
'verifyMailpoetSubscriber' => Expected::exactly(1), 'verifyMailpoetSubscriber' => Expected::exactly(1),
@@ -362,10 +346,10 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesWelcomeNewsletterWhenWPUserIsVerified() { public function testItProcessesWelcomeNewsletterWhenWPUserIsVerified() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletter->event = 'user'; $this->newsletterOptionFactory->create($newsletter, 'event', 'user');
// return true when WP user is verified // return true when WP user is verified
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->setSubscribers([1]); $queue->setSubscribers([1]);
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
'verifyWPSubscriber' => Expected::exactly(1), 'verifyWPSubscriber' => Expected::exactly(1),
@@ -384,7 +368,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItFailsMailpoetSubscriberVerificationWhenSubscriberDoesNotExist() { public function testItFailsMailpoetSubscriberVerificationWhenSubscriberDoesNotExist() {
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
// return false // return false
$result = $scheduler->verifyMailpoetSubscriber(null, $newsletter, $queue); $result = $scheduler->verifyMailpoetSubscriber(null, $newsletter, $queue);
@@ -398,15 +382,10 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment(); $segment = $this->_createSegment();
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsInt($segment->getId()); $this->assertIsInt($segment->getId());
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->getId()); $this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_NOTIFICATION) $queue = $this->_createQueue($newsletter->getId());
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return false // return false
@@ -430,15 +409,10 @@ class SchedulerTest extends \MailPoetTest {
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId()); $this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsInt($segment->getId()); $this->assertIsInt($segment->getId());
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->getId()); $this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_NOTIFICATION) $queue = $this->_createQueue($newsletter->getId());
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return false // return false
@@ -459,14 +433,11 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment(); $segment = $this->_createSegment();
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId()); $this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsInt($segment->getId()); $this->assertIsInt($segment->getId());
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->getId()); $this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_NOTIFICATION)
->findOne($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return false // return false
@@ -481,14 +452,11 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment(); $segment = $this->_createSegment();
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId()); $this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsInt($segment->getId()); $this->assertIsInt($segment->getId());
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->getId()); $this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_NOTIFICATION)
->findOne($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
// return true after successful verification // return true after successful verification
@@ -501,16 +469,11 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment(); $segment = $this->_createSegment();
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId()); $this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$this->_createNewsletterSegment($newsletter->id, $segment->getId()); $this->_createNewsletterSegment($newsletter->getId(), $segment->getId());
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsInt($segment->getId()); $this->assertIsInt($segment->getId());
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->getId()); $queue = $this->_createQueue($newsletter->getId());
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$queue = $this->_createQueue($newsletter->id);
$scheduler = $this->getScheduler($this->subscribersFinder); $scheduler = $this->getScheduler($this->subscribersFinder);
$this->entityManager->refresh($newsletter);
// return true // return true
expect($scheduler->processScheduledStandardNewsletter($newsletter, $queue))->true(); expect($scheduler->processScheduledStandardNewsletter($newsletter, $queue))->true();
@@ -527,14 +490,14 @@ class SchedulerTest extends \MailPoetTest {
// set queue's status to null // set queue's status to null
expect($scheduledTask->getStatus())->null(); expect($scheduledTask->getStatus())->null();
// set newsletter's status to sending // set newsletter's status to sending
$updatedNewsletter = Newsletter::findOne($newsletter->id); $updatedNewsletter = $this->newslettersRepository->findOneById($newsletter->getId());
$this->assertInstanceOf(Newsletter::class, $updatedNewsletter); $this->assertInstanceOf(NewsletterEntity::class, $updatedNewsletter);
expect($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENDING); expect($updatedNewsletter->getStatus())->equals(NewsletterEntity::STATUS_SENDING);
} }
public function testItFailsToProcessPostNotificationNewsletterWhenSegmentsDontExist() { public function testItFailsToProcessPostNotificationNewsletterWhenSegmentsDontExist() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
// delete or reschedule queue when segments don't exist // delete or reschedule queue when segments don't exist
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
@@ -550,9 +513,9 @@ class SchedulerTest extends \MailPoetTest {
public function testItFailsToProcessPostNotificationNewsletterWhenSubscribersNotInSegment() { public function testItFailsToProcessPostNotificationNewsletterWhenSubscribersNotInSegment() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$segment = $this->_createSegment(); $segment = $this->_createSegment();
$this->_createNewsletterSegment($newsletter->id, $segment->getId()); $this->_createNewsletterSegment($newsletter->getId(), $segment->getId());
// delete or reschedule queue when there are no subscribers in segments // delete or reschedule queue when there are no subscribers in segments
$scheduler = $this->construct( $scheduler = $this->construct(
@@ -579,26 +542,21 @@ class SchedulerTest extends \MailPoetTest {
public function testItCanProcessPostNotificationNewsletter() { public function testItCanProcessPostNotificationNewsletter() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$segment = $this->_createSegment(); $segment = $this->_createSegment();
$this->_createNewsletterSegment($newsletter->id, $segment->getId()); $this->_createNewsletterSegment($newsletter->getId(), $segment->getId());
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId()); $this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsInt($segment->getId()); $this->assertIsInt($segment->getId());
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->getId()); $this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
$newsletter = Newsletter::filter('filterWithOptions', NewsletterEntity::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$scheduler = $this->getScheduler($this->subscribersFinder); $scheduler = $this->getScheduler($this->subscribersFinder);
$this->entityManager->refresh($newsletter);
// return true // return true
expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->true(); expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->true();
// create notification history // create notification history
$notificationHistory = Newsletter::where('parent_id', $newsletter->id) $notificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter->getId()]);
->findOne(); $this->assertInstanceOf(NewsletterEntity::class, $notificationHistory);
$this->assertInstanceOf(Newsletter::class, $notificationHistory);
expect($notificationHistory)->notEmpty(); expect($notificationHistory)->notEmpty();
// update queue with a list of subscribers to process and change newsletter id // update queue with a list of subscribers to process and change newsletter id
// to that of the notification history // to that of the notification history
@@ -613,11 +571,11 @@ class SchedulerTest extends \MailPoetTest {
expect($updatedSubscribersIds)->equals([$subscriber->getId()]); expect($updatedSubscribersIds)->equals([$subscriber->getId()]);
$scheduledNewsletter = $sendingQueue->getNewsletter(); $scheduledNewsletter = $sendingQueue->getNewsletter();
$this->assertInstanceOf(NewsletterEntity::class, $scheduledNewsletter); $this->assertInstanceOf(NewsletterEntity::class, $scheduledNewsletter);
expect($scheduledNewsletter->getId())->equals($notificationHistory->id); expect($scheduledNewsletter->getId())->equals($notificationHistory->getId());
expect($sendingQueue->getCountProcessed())->equals(0); expect($sendingQueue->getCountProcessed())->equals(0);
expect($sendingQueue->getCountToProcess())->equals(1); expect($sendingQueue->getCountToProcess())->equals(1);
// set notification history's status to sending // set notification history's status to sending
$updatedNotificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter->id]); $updatedNotificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter->getId()]);
$this->assertInstanceOf(NewsletterEntity::class, $updatedNotificationHistory); $this->assertInstanceOf(NewsletterEntity::class, $updatedNotificationHistory);
expect($updatedNotificationHistory->getStatus())->equals(NewsletterEntity::STATUS_SENDING); expect($updatedNotificationHistory->getStatus())->equals(NewsletterEntity::STATUS_SENDING);
} }
@@ -638,9 +596,11 @@ class SchedulerTest extends \MailPoetTest {
public function testItDeletesQueueDuringProcessingWhenNewsletterIsSoftDeleted() { public function testItDeletesQueueDuringProcessingWhenNewsletterIsSoftDeleted() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$newsletter->deletedAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $newsletter->setDeletedAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
$newsletter->save(); $this->newslettersRepository->persist($newsletter);
$queue = $this->_createQueue($newsletter->id); $this->newslettersRepository->flush();
$queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
@@ -650,7 +610,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesWelcomeNewsletters() { public function testItProcessesWelcomeNewsletters() {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
@@ -663,7 +623,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesNotificationNewsletters() { public function testItProcessesNotificationNewsletters() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
@@ -676,7 +636,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesStandardScheduledNewsletters() { public function testItProcessesStandardScheduledNewsletters() {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
@@ -689,7 +649,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItEnforcesExecutionLimitDuringProcessing() { public function testItEnforcesExecutionLimitDuringProcessing() {
$newsletter = $this->_createNewsletter(); $newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
$scheduler = Stub::make(Scheduler::class, [ $scheduler = Stub::make(Scheduler::class, [
@@ -704,7 +664,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItDoesNotProcessScheduledJobsWhenNewsletterIsNotActive() { public function testItDoesNotProcessScheduledJobsWhenNewsletterIsNotActive() {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_DRAFT); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_DRAFT);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
@@ -719,7 +679,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesScheduledJobsWhenNewsletterIsActive() { public function testItProcessesScheduledJobsWhenNewsletterIsActive() {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_ACTIVE); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_ACTIVE);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
@@ -740,7 +700,7 @@ class SchedulerTest extends \MailPoetTest {
); );
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_DRAFT); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_DRAFT);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
$scheduler->processScheduledStandardNewsletter($newsletter, $queue); $scheduler->processScheduledStandardNewsletter($newsletter, $queue);
@@ -753,10 +713,9 @@ class SchedulerTest extends \MailPoetTest {
* @dataProvider dataForTestItSchedulesTransactionalEmails * @dataProvider dataForTestItSchedulesTransactionalEmails
*/ */
public function testItSchedulesTransactionalEmails(string $subscriberStatus, bool $isExpectedToBeScheduled) { public function testItSchedulesTransactionalEmails(string $subscriberStatus, bool $isExpectedToBeScheduled) {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION_TRANSACTIONAL, NewsletterEntity::STATUS_SCHEDULED); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION_TRANSACTIONAL, NewsletterEntity::STATUS_SCHEDULED);
$subscriber = $this->_createSubscriber(0, $subscriberStatus); $subscriber = $this->_createSubscriber(0, $subscriberStatus);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->setSubscribers([$subscriber->getId()]); $queue->setSubscribers([$subscriber->getId()]);
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
@@ -766,7 +725,7 @@ class SchedulerTest extends \MailPoetTest {
$scheduler = $this->diContainer->get(Scheduler::class); $scheduler = $this->diContainer->get(Scheduler::class);
$scheduler->process(); $scheduler->process();
$queue = SendingTask::getByNewsletterId($newsletter->id); $queue = SendingTask::getByNewsletterId($newsletter->getId());
$isExpectedToBeScheduled ? $isExpectedToBeScheduled ?
$this->assertSame(null, $queue->status) $this->assertSame(null, $queue->status)
: $this->assertFalse($queue); : $this->assertFalse($queue);
@@ -784,7 +743,7 @@ class SchedulerTest extends \MailPoetTest {
public function testItProcessesScheduledJobsWhenNewsletterIsScheduled() { public function testItProcessesScheduledJobsWhenNewsletterIsScheduled() {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_SCHEDULED); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_SCHEDULED);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->save(); $queue->save();
@@ -801,22 +760,22 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED);
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$task = SendingTask::create(); $task = SendingTask::create();
$task->newsletterId = $newsletter->id; $task->newsletterId = $newsletter->getId();
$task->status = SendingQueueEntity::STATUS_SCHEDULED; $task->status = SendingQueueEntity::STATUS_SCHEDULED;
$task->scheduledAt = Carbon::now()->subDay()->toDateTimeString(); $task->scheduledAt = Carbon::now()->subDay()->toDateTimeString();
$task->setSubscribers([$subscriber->getId()]); $task->setSubscribers([$subscriber->getId()]);
$task->save(); $task->save();
// scheduled task should exist // scheduled task should exist
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED); expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED);
expect($task->newsletterId)->equals($newsletter->id); expect($task->newsletterId)->equals($newsletter->getId());
expect($task->getSubscribers())->equals([$subscriber->getId()]); expect($task->getSubscribers())->equals([$subscriber->getId()]);
// task should have its status set to null (i.e., sending) // task should have its status set to null (i.e., sending)
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
$scheduler->process(); $scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->null(); expect($task->status)->null();
} }
@@ -824,7 +783,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED);
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$task = SendingTask::create(); $task = SendingTask::create();
$task->newsletterId = $newsletter->id; $task->newsletterId = $newsletter->getId();
$task->status = SendingQueueEntity::STATUS_SCHEDULED; $task->status = SendingQueueEntity::STATUS_SCHEDULED;
$task->scheduledAt = Carbon::now()->subDay()->toDateTimeString(); $task->scheduledAt = Carbon::now()->subDay()->toDateTimeString();
$task->setSubscribers([$subscriber->getId()]); $task->setSubscribers([$subscriber->getId()]);
@@ -832,15 +791,15 @@ class SchedulerTest extends \MailPoetTest {
$this->subscribersRepository->bulkDelete([$subscriber->getId()]); $this->subscribersRepository->bulkDelete([$subscriber->getId()]);
// scheduled task should exist // scheduled task should exist
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED); expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED);
expect($task->newsletterId)->equals($newsletter->id); expect($task->newsletterId)->equals($newsletter->getId());
expect($task->getSubscribers())->equals([$subscriber->getId()]); expect($task->getSubscribers())->equals([$subscriber->getId()]);
// task should be deleted // task should be deleted
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
$scheduler->process(); $scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task)->false(); expect($task)->false();
} }
@@ -850,7 +809,7 @@ class SchedulerTest extends \MailPoetTest {
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId()); $this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id); $newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->createMultipleOptions( $this->newsletterOptionFactory->createMultipleOptions(
$newsletterEntity, $newsletterEntity,
@@ -861,20 +820,20 @@ class SchedulerTest extends \MailPoetTest {
); );
$task = SendingTask::create(); $task = SendingTask::create();
$task->newsletterId = $newsletter->id; $task->newsletterId = $newsletter->getId();
$task->status = SendingQueueEntity::STATUS_SCHEDULED; $task->status = SendingQueueEntity::STATUS_SCHEDULED;
$task->scheduledAt = Carbon::now()->subDay()->toDateTimeString(); $task->scheduledAt = Carbon::now()->subDay()->toDateTimeString();
$task->save(); $task->save();
// scheduled task should exist // scheduled task should exist
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED); expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED);
expect($task->newsletterId)->equals($newsletter->id); expect($task->newsletterId)->equals($newsletter->getId());
// task should have its status set to null (i.e., sending) // task should have its status set to null (i.e., sending)
$scheduler = $this->getScheduler($this->subscribersFinder); $scheduler = $this->getScheduler($this->subscribersFinder);
$scheduler->process(); $scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->null(); expect($task->status)->null();
// task should have 1 subscriber added from segment // task should have 1 subscriber added from segment
$subscribers = $task->subscribers()->findMany(); $subscribers = $task->subscribers()->findMany();
@@ -886,22 +845,22 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION, NewsletterEntity::STATUS_ACTIVE); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION, NewsletterEntity::STATUS_ACTIVE);
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$task = SendingTask::create(); $task = SendingTask::create();
$task->newsletterId = $newsletter->id; $task->newsletterId = $newsletter->getId();
$task->status = SendingQueueEntity::STATUS_SCHEDULED; $task->status = SendingQueueEntity::STATUS_SCHEDULED;
$task->scheduledAt = Carbon::now()->subDay()->toDateTimeString(); $task->scheduledAt = Carbon::now()->subDay()->toDateTimeString();
$task->setSubscribers([$subscriber->getId()]); $task->setSubscribers([$subscriber->getId()]);
$task->save(); $task->save();
// scheduled task should exist // scheduled task should exist
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED); expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED);
expect($task->newsletterId)->equals($newsletter->id); expect($task->newsletterId)->equals($newsletter->getId());
expect($task->getSubscribers())->equals([$subscriber->getId()]); expect($task->getSubscribers())->equals([$subscriber->getId()]);
// task should have its status set to null (i.e., sending) // task should have its status set to null (i.e., sending)
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
$scheduler->process(); $scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->null(); expect($task->status)->null();
} }
@@ -909,7 +868,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION, NewsletterEntity::STATUS_ACTIVE); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION, NewsletterEntity::STATUS_ACTIVE);
$subscriber = $this->_createSubscriber(); $subscriber = $this->_createSubscriber();
$task = SendingTask::create(); $task = SendingTask::create();
$task->newsletterId = $newsletter->id; $task->newsletterId = $newsletter->getId();
$task->status = SendingQueueEntity::STATUS_SCHEDULED; $task->status = SendingQueueEntity::STATUS_SCHEDULED;
$task->scheduledAt = Carbon::now()->subDay()->toDateTimeString(); $task->scheduledAt = Carbon::now()->subDay()->toDateTimeString();
$task->setSubscribers([$subscriber->getId()]); $task->setSubscribers([$subscriber->getId()]);
@@ -917,22 +876,22 @@ class SchedulerTest extends \MailPoetTest {
$this->subscribersRepository->bulkDelete([$subscriber->getId()]); $this->subscribersRepository->bulkDelete([$subscriber->getId()]);
// scheduled task should exist // scheduled task should exist
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED); expect($task->status)->equals(SendingQueueEntity::STATUS_SCHEDULED);
expect($task->newsletterId)->equals($newsletter->id); expect($task->newsletterId)->equals($newsletter->getId());
expect($task->getSubscribers())->equals([$subscriber->getId()]); expect($task->getSubscribers())->equals([$subscriber->getId()]);
// task should be deleted // task should be deleted
$scheduler = $this->getScheduler(); $scheduler = $this->getScheduler();
$scheduler->process(); $scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id); $task = SendingTask::getByNewsletterId($newsletter->getId());
expect($task)->false(); expect($task)->false();
} }
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)->toDateTimeString();
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME, NewsletterEntity::STATUS_DRAFT); $newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME, NewsletterEntity::STATUS_DRAFT);
$queue = $this->_createQueue($newsletter->id); $queue = $this->_createQueue($newsletter->getId());
$queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $queue->scheduledAt = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$queue->updatedAt = $originalUpdated; $queue->updatedAt = $originalUpdated;
$queue->save(); $queue->save();
@@ -989,12 +948,12 @@ class SchedulerTest extends \MailPoetTest {
return $subscriber; return $subscriber;
} }
public function _createNewsletter($type = NewsletterEntity::TYPE_NOTIFICATION, $status = 'active') { public function _createNewsletter($type = NewsletterEntity::TYPE_NOTIFICATION, $status = 'active'): NewsletterEntity {
$newsletter = Newsletter::create(); $newsletter = $this->newsletterFactory
$newsletter->type = $type; ->withType($type)
$newsletter->status = $status; ->withStatus($status)
$newsletter->save(); ->create();
expect($newsletter->getErrors())->false();
return $newsletter; return $newsletter;
} }