dd5a11a34f
Having no segment and no task subscriber caused the test pass even without removing the subscriber. [MAILPOET-4375]
1014 lines
44 KiB
PHP
1014 lines
44 KiB
PHP
<?php declare(strict_types = 1);
|
|
|
|
namespace MailPoet\Test\Cron\Workers;
|
|
|
|
use Codeception\Stub;
|
|
use Codeception\Stub\Expected;
|
|
use MailPoet\Cron\CronHelper;
|
|
use MailPoet\Cron\CronWorkerScheduler;
|
|
use MailPoet\Cron\Workers\Scheduler;
|
|
use MailPoet\Cron\Workers\SendingQueue\SendingQueue;
|
|
use MailPoet\Entities\NewsletterEntity;
|
|
use MailPoet\Entities\NewsletterOptionFieldEntity;
|
|
use MailPoet\Entities\NewsletterSegmentEntity;
|
|
use MailPoet\Entities\ScheduledTaskEntity;
|
|
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
|
|
use MailPoet\Entities\SegmentEntity;
|
|
use MailPoet\Entities\SendingQueueEntity;
|
|
use MailPoet\Entities\SubscriberEntity;
|
|
use MailPoet\Entities\SubscriberSegmentEntity;
|
|
use MailPoet\Logging\LoggerFactory;
|
|
use MailPoet\Newsletter\NewslettersRepository;
|
|
use MailPoet\Newsletter\Scheduler\Scheduler as NewsletterScheduler;
|
|
use MailPoet\Newsletter\Scheduler\WelcomeScheduler;
|
|
use MailPoet\Newsletter\Segment\NewsletterSegmentRepository;
|
|
use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
|
|
use MailPoet\Newsletter\Sending\ScheduledTaskSubscribersRepository;
|
|
use MailPoet\Newsletter\Sending\SendingQueuesRepository;
|
|
use MailPoet\Segments\SegmentsRepository;
|
|
use MailPoet\Segments\SubscribersFinder;
|
|
use MailPoet\Subscribers\SubscriberSegmentRepository;
|
|
use MailPoet\Subscribers\SubscribersRepository;
|
|
use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
|
|
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
|
|
use MailPoet\Test\DataFactories\ScheduledTask as ScheduledTaskFactory;
|
|
use MailPoet\Test\DataFactories\Segment as SegmentFactory;
|
|
use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory;
|
|
use MailPoet\Util\Security;
|
|
use MailPoet\WP\Functions as WPFunctions;
|
|
use MailPoetVendor\Carbon\Carbon;
|
|
use WP_User;
|
|
|
|
class SchedulerTest extends \MailPoetTest {
|
|
public $cronHelper;
|
|
/** @var LoggerFactory */
|
|
private $loggerFactory;
|
|
|
|
/** @var SubscribersFinder */
|
|
private $subscribersFinder;
|
|
|
|
/** @var CronWorkerScheduler */
|
|
private $cronWorkerScheduler;
|
|
|
|
/** @var ScheduledTasksRepository */
|
|
private $scheduledTasksRepository;
|
|
|
|
/** @var NewslettersRepository */
|
|
private $newslettersRepository;
|
|
|
|
/** @var SegmentsRepository */
|
|
private $segmentsRepository;
|
|
|
|
/** @var NewsletterScheduler */
|
|
private $newsletterScheduler;
|
|
|
|
/** @var NewsletterOptionFactory */
|
|
private $newsletterOptionFactory;
|
|
|
|
/** @var NewsletterSegmentRepository */
|
|
private $newsletterSegmentRepository;
|
|
|
|
/** @var Security */
|
|
private $security;
|
|
|
|
/** @var SendingQueuesRepository */
|
|
private $sendingQueuesRepository;
|
|
|
|
/** @var SubscriberSegmentRepository */
|
|
private $subscriberSegmentRepository;
|
|
|
|
/** @var SubscriberFactory */
|
|
private $subscriberFactory;
|
|
|
|
/** @var SubscribersRepository */
|
|
private $subscribersRepository;
|
|
|
|
/** @var SegmentFactory */
|
|
private $segmentFactory;
|
|
|
|
/** @var ScheduledTaskFactory */
|
|
private $scheduledTaskFactory;
|
|
|
|
/** @var NewsletterFactory */
|
|
private $newsletterFactory;
|
|
|
|
public function _before() {
|
|
parent::_before();
|
|
$this->loggerFactory = LoggerFactory::getInstance();
|
|
$this->cronHelper = $this->diContainer->get(CronHelper::class);
|
|
$this->subscribersFinder = $this->diContainer->get(SubscribersFinder::class);
|
|
$this->cronWorkerScheduler = $this->diContainer->get(CronWorkerScheduler::class);
|
|
$this->scheduledTasksRepository = $this->diContainer->get(ScheduledTasksRepository::class);
|
|
$this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
|
|
$this->segmentsRepository = $this->diContainer->get(SegmentsRepository::class);
|
|
$this->newsletterScheduler = $this->diContainer->get(NewsletterScheduler::class);
|
|
$this->newsletterOptionFactory = new NewsletterOptionFactory();
|
|
$this->newsletterSegmentRepository = $this->diContainer->get(NewsletterSegmentRepository::class);
|
|
$this->security = $this->diContainer->get(Security::class);
|
|
$this->sendingQueuesRepository = $this->diContainer->get(SendingQueuesRepository::class);
|
|
$this->subscriberSegmentRepository = $this->diContainer->get(SubscriberSegmentRepository::class);
|
|
$this->subscriberFactory = new SubscriberFactory();
|
|
$this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class);
|
|
$this->segmentFactory = new SegmentFactory();
|
|
$this->scheduledTaskFactory = new ScheduledTaskFactory();
|
|
$this->newsletterFactory = new NewsletterFactory();
|
|
}
|
|
|
|
public function testItThrowsExceptionWhenExecutionLimitIsReached() {
|
|
try {
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process(microtime(true) - $this->cronHelper->getDaemonExecutionLimit());
|
|
self::fail('Maximum execution time limit exception was not thrown.');
|
|
} catch (\Exception $e) {
|
|
verify($e->getMessage())->stringStartsWith('The maximum execution time');
|
|
}
|
|
}
|
|
|
|
public function testItCanGetScheduledQueues() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$scheduler = $this->diContainer->get(Scheduler::class);
|
|
verify($scheduler->getScheduledSendingTasks())->empty();
|
|
$this->createTaskWithQueue($newsletter);
|
|
verify($scheduler->getScheduledSendingTasks())->notEmpty();
|
|
}
|
|
|
|
public function testItCanCreateNotificationHistory() {
|
|
$segments[] = $this->segmentFactory
|
|
->withName('Segment A')
|
|
->create();
|
|
$segments[] = $this->segmentFactory
|
|
->withName('Segment B')
|
|
->create();
|
|
$newsletter = $this->newsletterFactory
|
|
->withType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY)
|
|
->withSegments($segments)
|
|
->create();
|
|
|
|
// ensure that notification history does not exist
|
|
$notificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter, 'type' => NewsletterEntity::TYPE_NOTIFICATION_HISTORY]);
|
|
verify($notificationHistory)->empty();
|
|
|
|
// create notification history and ensure that it exists
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->createPostNotificationHistory($newsletter);
|
|
$notificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter, 'type' => NewsletterEntity::TYPE_NOTIFICATION_HISTORY]);
|
|
verify($notificationHistory)->notEmpty();
|
|
$this->assertInstanceOf(NewsletterEntity::class, $notificationHistory);
|
|
// check the hash of the post notification history
|
|
verify($notificationHistory->getHash())->notEquals($newsletter->getHash());
|
|
verify(strlen((string)$notificationHistory->getHash()))->equals(Security::HASH_LENGTH);
|
|
// check the unsubscribe token of the post notification history
|
|
verify($notificationHistory->getUnsubscribeToken())->notEquals($newsletter->getUnsubscribeToken());
|
|
verify(strlen((string)$notificationHistory->getUnsubscribeToken()))->equals(Security::UNSUBSCRIBE_TOKEN_LENGTH);
|
|
|
|
verify($notificationHistory->getParent())->equals($newsletter);
|
|
verify($notificationHistory->getNewsletterSegments())->arrayCount(count($segments));
|
|
}
|
|
|
|
public function testItCanDeleteQueueWhenDeliveryIsSetToImmediately() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->getId());
|
|
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
|
|
$this->newsletterOptionFactory->create($newsletterEntity, 'intervalType', 'immediately');
|
|
|
|
$newsletter = $this->newslettersRepository->findOneById($newsletter->getId());
|
|
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// queue and associated newsletter should be deleted when interval type is set to "immediately"
|
|
verify($this->sendingQueuesRepository->findAll())->notEmpty();
|
|
$scheduler->deleteQueueOrUpdateNextRunDate($task, $newsletter);
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItCanRescheduleQueueDeliveryTime() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
|
|
$newsletterOption = $this->newsletterOptionFactory->create($newsletter, 'intervalType', 'daily');
|
|
|
|
$newsletter = $this->newslettersRepository->findOneById($newsletter->getId());
|
|
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// queue's next run date should change when interval type is set to anything
|
|
// other than "immediately"
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(null);
|
|
$newsletterOption->setValue('daily');
|
|
$this->entityManager->persist($newsletterOption);
|
|
$this->entityManager->flush();
|
|
|
|
$newsletter = $this->newslettersRepository->findOneById($newsletter->getId());
|
|
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
|
|
verify($task->getScheduledAt())->null();
|
|
|
|
$this->newsletterOptionFactory->create($newsletter, NewsletterOptionFieldEntity::NAME_SCHEDULE, '0 5 * * *');
|
|
|
|
$scheduler->deleteQueueOrUpdateNextRunDate($task, $newsletter);
|
|
|
|
$queueEntity = $task->getSendingQueue();
|
|
$this->assertInstanceOf(SendingQueueEntity::class, $queueEntity);
|
|
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($queueEntity);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
|
|
verify($scheduledTask->getScheduledAt())->notNull();
|
|
}
|
|
|
|
public function testItFailsWPSubscriberVerificationWhenSubscriberIsNotAWPUser() {
|
|
$wPUser = $this->_createOrUpdateWPUser('editor');
|
|
$subscriber = $this->_createSubscriber();
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
|
|
|
|
$this->newsletterOptionFactory->create($newsletter, 'role', 'author');
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// return false and delete queue when subscriber is not a WP user
|
|
$result = $scheduler->verifyWPSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->false();
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItFailsWPSubscriberVerificationWhenSubscriberRoleDoesNotMatch() {
|
|
$wPUser = $this->_createOrUpdateWPUser('editor');
|
|
$subscriber = $this->_createSubscriber($wPUser->ID);
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
|
|
|
|
$this->newsletterOptionFactory->create($newsletter, 'role', 'author');
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// return false and delete queue when subscriber role is different from the one
|
|
// specified for the welcome email
|
|
$result = $scheduler->verifyWPSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->false();
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItPassesWPSubscriberVerificationWhenSubscriberExistsAndRoleMatches() {
|
|
$wPUser = $this->_createOrUpdateWPUser('author');
|
|
$subscriber = $this->_createSubscriber($wPUser->ID);
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
|
|
|
|
$this->newsletterOptionFactory->create($newsletter, 'role', 'author');
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// return true when user exists and WP role matches the one specified for the welcome email
|
|
$result = $scheduler->verifyWPSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->true();
|
|
verify(count($this->sendingQueuesRepository->findAll()))->greaterThanOrEqual(1);
|
|
}
|
|
|
|
public function testItPassesWPSubscriberVerificationWhenSubscriberHasAnyRole() {
|
|
$wPUser = $this->_createOrUpdateWPUser('author');
|
|
$subscriber = $this->_createSubscriber($wPUser->ID);
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
|
|
|
|
$this->newsletterOptionFactory->create($newsletter, 'role', WelcomeScheduler::WORDPRESS_ALL_ROLES);
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// true when user exists and has any role
|
|
$result = $scheduler->verifyWPSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->true();
|
|
verify(count($this->sendingQueuesRepository->findAll()))->greaterThanOrEqual(1);
|
|
}
|
|
|
|
public function testItDoesNotProcessWelcomeNewsletterWhenThereAreNoSubscribersToProcess() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
|
|
// delete queue when the list of subscribers to process is blank
|
|
$scheduler = $this->getScheduler();
|
|
$result = $scheduler->processWelcomeNewsletter($newsletter, $task);
|
|
verify($result)->false();
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItDoesNotProcessWelcomeNewsletterWhenWPUserCannotBeVerified() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->newsletterOptionFactory->create($newsletter, 'event', 'user');
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
|
|
// return false when WP user cannot be verified
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'verifyWPSubscriber' => Expected::exactly(1, function() {
|
|
return false;
|
|
}),
|
|
], $this);
|
|
verify($scheduler->processWelcomeNewsletter($newsletter, $task))->false();
|
|
}
|
|
|
|
public function testItDoesNotProcessWelcomeNewsletterWhenSubscriberCannotBeVerified() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->newsletterOptionFactory->create($newsletter, 'event', 'segment');
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
|
|
// return false when subscriber cannot be verified
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'verifyMailpoetSubscriber' => Expected::exactly(1, function() {
|
|
return false;
|
|
}),
|
|
], $this);
|
|
verify($scheduler->processWelcomeNewsletter($newsletter, $task))->false();
|
|
}
|
|
|
|
public function testItProcessesWelcomeNewsletterWhenSubscriberIsVerified() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->newsletterOptionFactory->create($newsletter, 'event', 'segment');
|
|
|
|
// return true when subsriber is verified and update the queue's status to null
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'verifyMailpoetSubscriber' => Expected::exactly(1, true),
|
|
'scheduledTasksRepository' => $this->diContainer->get(ScheduledTasksRepository::class),
|
|
], $this);
|
|
verify($task->getStatus())->notNull();
|
|
verify($scheduler->processWelcomeNewsletter($newsletter, $task))->true();
|
|
$sendingQueue = $task->getSendingQueue();
|
|
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
|
|
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
|
|
verify($scheduledTask->getStatus())->null();
|
|
}
|
|
|
|
public function testItProcessesWelcomeNewsletterWhenWPUserIsVerified() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->newsletterOptionFactory->create($newsletter, 'event', 'user');
|
|
|
|
// return true when WP user is verified
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'verifyWPSubscriber' => Expected::exactly(1, true),
|
|
'scheduledTasksRepository' => $this->diContainer->get(ScheduledTasksRepository::class),
|
|
], $this);
|
|
verify($task->getStatus())->notNull();
|
|
verify($scheduler->processWelcomeNewsletter($newsletter, $task))->true();
|
|
// update queue's status to null
|
|
$sendingQueue = $task->getSendingQueue();
|
|
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
|
|
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
|
|
verify($scheduledTask->getStatus())->null();
|
|
}
|
|
|
|
public function testItFailsMailpoetSubscriberVerificationWhenSubscriberDoesNotExist() {
|
|
$scheduler = $this->getScheduler();
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
|
|
// return false
|
|
$result = $scheduler->verifyMailpoetSubscriber(PHP_INT_MAX, $newsletter, $task);
|
|
verify($result)->false();
|
|
// delete queue when subscriber can't be found
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItFailsMailpoetSubscriberVerificationWhenSubscriberIsNotInSegment() {
|
|
$subscriber = $this->_createSubscriber();
|
|
$segment = $this->_createSegment();
|
|
$newsletter = $this->_createNewsletter();
|
|
|
|
$this->assertIsInt($segment->getId());
|
|
$this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// return false
|
|
$result = $scheduler->verifyMailpoetSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->false();
|
|
// delete queue when subscriber is not in segment specified for the newsletter
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItReschedulesQueueDeliveryWhenMailpoetSubscriberHasNotConfirmedSubscription() {
|
|
$timestamp = WPFunctions::get()->currentTime('timestamp');
|
|
$wpFunctions = $this->make(WPFunctions::class, [
|
|
'currentTime' => $timestamp,
|
|
]);
|
|
WPFunctions::set($wpFunctions);
|
|
$currentTime = Carbon::createFromTimestamp($timestamp);
|
|
Carbon::setTestNow($currentTime); // mock carbon to return current time
|
|
|
|
$subscriber = $this->_createSubscriber(0, 'unconfirmed');
|
|
$segment = $this->_createSegment();
|
|
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
|
|
$newsletter = $this->_createNewsletter();
|
|
|
|
$this->assertIsInt($segment->getId());
|
|
$this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// return false
|
|
$result = $scheduler->verifyMailpoetSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->false();
|
|
// update the time queue is scheduled to run at
|
|
$sendingQueue = $task->getSendingQueue();
|
|
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
|
|
$scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
|
|
$this->tester->assertEqualDateTimes($scheduledTask->getScheduledAt(), $currentTime->addMinutes(ScheduledTaskEntity::BASIC_RESCHEDULE_TIMEOUT), 1);
|
|
}
|
|
|
|
public function testItDoesntRunQueueDeliveryWhenMailpoetSubscriberHasUnsubscribed() {
|
|
$currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
|
|
Carbon::setTestNow($currentTime); // mock carbon to return current time
|
|
$subscriber = $this->_createSubscriber(0, 'unsubscribed');
|
|
$segment = $this->_createSegment();
|
|
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
|
|
$newsletter = $this->_createNewsletter();
|
|
|
|
$this->assertIsInt($segment->getId());
|
|
$this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
$queue = $task->getSendingQueue();
|
|
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
|
|
$taskId = $task->getId();
|
|
$queueId = $queue->getId();
|
|
|
|
// return false
|
|
$result = $scheduler->verifyMailpoetSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->false();
|
|
// update the time queue is scheduled to run at
|
|
verify($this->scheduledTasksRepository->findOneById($taskId))->null();
|
|
verify($this->sendingQueuesRepository->findOneById($queueId))->null();
|
|
}
|
|
|
|
public function testItCanVerifyMailpoetSubscriber() {
|
|
$subscriber = $this->_createSubscriber();
|
|
$segment = $this->_createSegment();
|
|
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
|
|
$newsletter = $this->_createNewsletter();
|
|
|
|
$this->assertIsInt($segment->getId());
|
|
$this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
// return true after successful verification
|
|
$result = $scheduler->verifyMailpoetSubscriber((int)$subscriber->getId(), $newsletter, $task);
|
|
verify($result)->true();
|
|
}
|
|
|
|
public function testItProcessesScheduledStandardNewsletter() {
|
|
$subscriber = $this->_createSubscriber();
|
|
$segment = $this->_createSegment();
|
|
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
|
|
$newsletter = $this->_createNewsletter();
|
|
$this->_createNewsletterSegment($newsletter->getId(), $segment->getId());
|
|
$this->assertIsInt($segment->getId());
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler($this->subscribersFinder);
|
|
$this->entityManager->refresh($newsletter);
|
|
|
|
// return true
|
|
verify($scheduler->processScheduledStandardNewsletter($newsletter, $task))->true();
|
|
// update queue's list of subscribers to process
|
|
$updatedSubscribers = $task->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED);
|
|
$updatedSubscribersIds = array_map(function(SubscriberEntity $subscriber): int {
|
|
return (int)$subscriber->getId();
|
|
}, $updatedSubscribers);
|
|
verify($updatedSubscribersIds)->equals([$subscriber->getId()]);
|
|
// set queue's status to null
|
|
verify($task->getStatus())->null();
|
|
// set newsletter's status to sending
|
|
$updatedNewsletter = $this->newslettersRepository->findOneById($newsletter->getId());
|
|
$this->assertInstanceOf(NewsletterEntity::class, $updatedNewsletter);
|
|
verify($updatedNewsletter->getStatus())->equals(NewsletterEntity::STATUS_SENDING);
|
|
}
|
|
|
|
public function testItFailsToProcessPostNotificationNewsletterWhenSegmentsDontExist() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
|
|
// delete or reschedule queue when segments don't exist
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
|
|
return false;
|
|
}),
|
|
'loggerFactory' => $this->loggerFactory,
|
|
'cronHelper' => $this->cronHelper,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
verify($scheduler->processPostNotificationNewsletter($newsletter, $task))->false();
|
|
}
|
|
|
|
public function testItFailsToProcessPostNotificationNewsletterWhenSubscribersNotInSegment() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$segment = $this->_createSegment();
|
|
$this->_createNewsletterSegment($newsletter->getId(), $segment->getId());
|
|
|
|
// delete or reschedule queue when there are no subscribers in segments
|
|
$scheduler = $this->construct(
|
|
Scheduler::class,
|
|
[
|
|
$this->subscribersFinder,
|
|
$this->loggerFactory,
|
|
$this->cronHelper,
|
|
$this->cronWorkerScheduler,
|
|
$this->scheduledTasksRepository,
|
|
$this->diContainer->get(ScheduledTaskSubscribersRepository::class),
|
|
$this->sendingQueuesRepository,
|
|
$this->newslettersRepository,
|
|
$this->segmentsRepository,
|
|
$this->newsletterSegmentRepository,
|
|
WPFunctions::get(),
|
|
$this->security,
|
|
$this->newsletterScheduler,
|
|
$this->subscriberSegmentRepository,
|
|
$this->subscribersRepository,
|
|
], [
|
|
'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
|
|
return false;
|
|
}),
|
|
]);
|
|
verify($scheduler->processPostNotificationNewsletter($newsletter, $task))->false();
|
|
}
|
|
|
|
public function testItCanProcessPostNotificationNewsletter() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$segment = $this->_createSegment();
|
|
$this->_createNewsletterSegment($newsletter->getId(), $segment->getId());
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
|
|
$this->assertIsInt($segment->getId());
|
|
$this->newsletterOptionFactory->create($newsletter, 'segment', $segment->getId());
|
|
$scheduler = $this->getScheduler($this->subscribersFinder);
|
|
$this->entityManager->refresh($newsletter);
|
|
|
|
// return true
|
|
verify($scheduler->processPostNotificationNewsletter($newsletter, $task))->true();
|
|
// create notification history
|
|
$notificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter->getId()]);
|
|
$this->assertInstanceOf(NewsletterEntity::class, $notificationHistory);
|
|
verify($notificationHistory)->notEmpty();
|
|
// update queue with a list of subscribers to process and change newsletter id
|
|
// to that of the notification history
|
|
$sendingQueue = $task->getSendingQueue();
|
|
$this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
|
|
$updatedSubscribers = $task->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED);
|
|
$updatedSubscribersIds = array_map(function(SubscriberEntity $subscriber): int {
|
|
return (int)$subscriber->getId();
|
|
}, $updatedSubscribers);
|
|
verify($updatedSubscribersIds)->equals([$subscriber->getId()]);
|
|
$scheduledNewsletter = $sendingQueue->getNewsletter();
|
|
$this->assertInstanceOf(NewsletterEntity::class, $scheduledNewsletter);
|
|
verify($scheduledNewsletter->getId())->equals($notificationHistory->getId());
|
|
verify($sendingQueue->getCountProcessed())->equals(0);
|
|
verify($sendingQueue->getCountToProcess())->equals(1);
|
|
// set notification history's status to sending
|
|
$updatedNotificationHistory = $this->newslettersRepository->findOneBy(['parent' => $newsletter->getId()]);
|
|
$this->assertInstanceOf(NewsletterEntity::class, $updatedNotificationHistory);
|
|
verify($updatedNotificationHistory->getStatus())->equals(NewsletterEntity::STATUS_SENDING);
|
|
}
|
|
|
|
public function testItDeletesQueueDuringProcessingWhenNewsletterNotFound() {
|
|
$subscriber = $this->_createSubscriber();
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(1);
|
|
verify($this->scheduledTasksRepository->findOneByNewsletter($newsletter))->notNull();
|
|
|
|
// remove newsletter, but not any related data
|
|
$this->entityManager->getConnection()->delete(
|
|
$this->entityManager->getClassMetadata(NewsletterEntity::class)->getTableName(),
|
|
['id' => $newsletter->getId()]
|
|
);
|
|
$this->entityManager->clear();
|
|
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
verify($this->scheduledTasksRepository->findOneByNewsletter($newsletter))->null();
|
|
}
|
|
|
|
public function testItDeletesQueueDuringProcessingWhenNewsletterIsSoftDeleted() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$newsletter->setDeletedAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->newslettersRepository->persist($newsletter);
|
|
$this->newslettersRepository->flush();
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
verify($this->sendingQueuesRepository->findAll())->arrayCount(0);
|
|
}
|
|
|
|
public function testItProcessesWelcomeNewsletters() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processWelcomeNewsletter' => Expected::exactly(1),
|
|
'cronHelper' => $this->cronHelper,
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItProcessesNotificationNewsletters() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processPostNotificationNewsletter' => Expected::exactly(1),
|
|
'cronHelper' => $this->cronHelper,
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItProcessesStandardScheduledNewsletters() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processScheduledStandardNewsletter' => Expected::exactly(1),
|
|
'cronHelper' => $this->cronHelper,
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItEnforcesExecutionLimitDuringProcessing() {
|
|
$newsletter = $this->_createNewsletter();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processPostNotificationNewsletter' => Expected::exactly(1),
|
|
'cronHelper' => $this->make(CronHelper::class, [
|
|
'enforceExecutionLimit' => Expected::exactly(2), // call at start + during processing
|
|
]),
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItDoesNotProcessScheduledJobsWhenNewsletterIsNotActive() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_DRAFT);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processScheduledStandardNewsletter' => Expected::never(),
|
|
'cronHelper' => $this->cronHelper,
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
// scheduled job is not processed
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItProcessesScheduledJobsWhenNewsletterIsActive() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_ACTIVE);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processScheduledStandardNewsletter' => Expected::once(),
|
|
'cronHelper' => $this->cronHelper,
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
// scheduled job is processed
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItDoesNotReSchedulesBounceTaskWhenSoon() {
|
|
$task = $this->scheduledTaskFactory->create(
|
|
'bounce',
|
|
ScheduledTaskEntity::STATUS_SCHEDULED,
|
|
Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->addMinutes(5)
|
|
);
|
|
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_DRAFT);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$scheduler = $this->getScheduler();
|
|
|
|
$scheduler->processScheduledStandardNewsletter($newsletter, $task);
|
|
$refetchedTask = $this->scheduledTasksRepository->findOneById($task->getId());
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $refetchedTask);
|
|
verify($refetchedTask->getScheduledAt())->lessThan(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->addHours(1));
|
|
}
|
|
|
|
/**
|
|
* @dataProvider dataForTestItSchedulesTransactionalEmails
|
|
*/
|
|
public function testItSchedulesTransactionalEmails(string $subscriberStatus, bool $isExpectedToBeScheduled) {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION_TRANSACTIONAL, NewsletterEntity::STATUS_SCHEDULED);
|
|
$subscriber = $this->_createSubscriber(0, $subscriberStatus);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
$this->entityManager->flush();
|
|
|
|
$scheduler = $this->diContainer->get(Scheduler::class);
|
|
$scheduler->process();
|
|
|
|
$task = $this->scheduledTasksRepository->findOneByNewsletter($newsletter);
|
|
if ($isExpectedToBeScheduled) {
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $task);
|
|
$this->assertSame(null, $task->getStatus());
|
|
} else {
|
|
$this->assertNull($task);
|
|
}
|
|
}
|
|
|
|
public function dataForTestItSchedulesTransactionalEmails(): array {
|
|
return [
|
|
SubscriberEntity::STATUS_INACTIVE => [SubscriberEntity::STATUS_INACTIVE, true],
|
|
SubscriberEntity::STATUS_SUBSCRIBED => [SubscriberEntity::STATUS_SUBSCRIBED, true],
|
|
SubscriberEntity::STATUS_BOUNCED => [SubscriberEntity::STATUS_BOUNCED, false],
|
|
SubscriberEntity::STATUS_UNSUBSCRIBED => [SubscriberEntity::STATUS_UNSUBSCRIBED, true],
|
|
SubscriberEntity::STATUS_UNCONFIRMED => [SubscriberEntity::STATUS_UNCONFIRMED, true],
|
|
];
|
|
}
|
|
|
|
public function testItProcessesScheduledJobsWhenNewsletterIsScheduled() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_SCHEDULED);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$this->entityManager->flush();
|
|
|
|
$scheduler = Stub::make(Scheduler::class, [
|
|
'processScheduledStandardNewsletter' => Expected::once(),
|
|
'cronHelper' => $this->cronHelper,
|
|
'scheduledTasksRepository' => $this->scheduledTasksRepository,
|
|
'sendingQueuesRepository' => $this->sendingQueuesRepository,
|
|
'newslettersRepository' => $this->newslettersRepository,
|
|
], $this);
|
|
// scheduled job is processed
|
|
$scheduler->process();
|
|
}
|
|
|
|
public function testItProcessesScheduledAutomaticEmailWhenSendingToUser() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED);
|
|
$subscriber = $this->_createSubscriber();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
|
|
// task should have its status set to null (i.e., sending)
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
$task = $this->scheduledTasksRepository->findOneByNewsletter($newsletter);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $task);
|
|
verify($task->getStatus())->null();
|
|
}
|
|
|
|
public function testItDeletesScheduledAutomaticEmailWhenUserDoesNotExist() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED);
|
|
$subscriber = $this->_createSubscriber();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
|
|
verify($this->scheduledTasksRepository->findOneByNewsletter($newsletter))->notNull();
|
|
|
|
// remove subscriber, but not scheduled task subscriber
|
|
$this->entityManager->getConnection()->delete(
|
|
$this->entityManager->getClassMetadata(SubscriberEntity::class)->getTableName(),
|
|
['id' => $subscriber->getId()]
|
|
);
|
|
$this->entityManager->clear();
|
|
|
|
// task should be deleted
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
verify($this->scheduledTasksRepository->findOneByNewsletter($newsletter))->null();
|
|
}
|
|
|
|
public function testItProcessesScheduledAutomaticEmailWhenSendingToSegment() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATIC, NewsletterEntity::STATUS_SCHEDULED);
|
|
$segment = $this->_createSegment();
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->_createSubscriberSegment($subscriber->getId(), $segment->getId());
|
|
$this->newsletterOptionFactory->createMultipleOptions(
|
|
$newsletter,
|
|
[
|
|
'sendTo' => 'segment',
|
|
'segment' => $segment->getId(),
|
|
]
|
|
);
|
|
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::now()->subDay());
|
|
$this->entityManager->flush();
|
|
|
|
// task should have its status set to null (i.e., sending)
|
|
$scheduler = $this->getScheduler($this->subscribersFinder);
|
|
$scheduler->process();
|
|
|
|
$task = $this->scheduledTasksRepository->findOneByNewsletter($newsletter);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $task);
|
|
verify($task->getStatus())->null();
|
|
// task should have 1 subscriber added from segment
|
|
$subscribers = $task->getSubscribers();
|
|
$this->assertCount(1, $subscribers);
|
|
$this->assertInstanceOf(ScheduledTaskSubscriberEntity::class, $subscribers[0]);
|
|
$this->assertSame($subscriber, $subscribers[0]->getSubscriber());
|
|
}
|
|
|
|
public function testItProcessesScheduledAutomationEmail() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION, NewsletterEntity::STATUS_ACTIVE);
|
|
$subscriber = $this->_createSubscriber();
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$this->createTaskSubscriber($task, $subscriber);
|
|
|
|
// task should have its status set to null (i.e., sending)
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
$task = $this->scheduledTasksRepository->findOneByNewsletter($newsletter);
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $task);
|
|
verify($task->getStatus())->null();
|
|
}
|
|
|
|
public function testItDeletesScheduledAutomationEmailWhenUserDoesNotExist() {
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_AUTOMATION, NewsletterEntity::STATUS_ACTIVE);
|
|
$subscriber = $this->_createSubscriber();
|
|
$this->createTaskWithQueue($newsletter);
|
|
|
|
// remove subscriber, but not scheduled task subscriber
|
|
$this->entityManager->getConnection()->delete(
|
|
$this->entityManager->getClassMetadata(SubscriberEntity::class)->getTableName(),
|
|
['id' => $subscriber->getId()]
|
|
);
|
|
$this->entityManager->clear();
|
|
|
|
// task should be deleted
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
$task = $this->scheduledTasksRepository->findOneByNewsletter($newsletter);
|
|
verify($task)->null();
|
|
}
|
|
|
|
public function testItUpdatesUpdateTime() {
|
|
$originalUpdated = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->subHours(5);
|
|
$newsletter = $this->_createNewsletter(NewsletterEntity::TYPE_WELCOME, NewsletterEntity::STATUS_DRAFT);
|
|
$task = $this->createTaskWithQueue($newsletter);
|
|
$task->setScheduledAt(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')));
|
|
$task->setUpdatedAt($originalUpdated);
|
|
$this->entityManager->flush();
|
|
$scheduler = $this->getScheduler();
|
|
$scheduler->process();
|
|
$newTask = $this->scheduledTasksRepository->findOneById($task->getId());
|
|
$this->assertInstanceOf(ScheduledTaskEntity::class, $newTask);
|
|
verify($newTask->getUpdatedAt())->notEquals($originalUpdated);
|
|
}
|
|
|
|
public function _createNewsletterSegment($newsletterId, $segmentId) {
|
|
$newsletter = $this->entityManager->getReference(NewsletterEntity::class, $newsletterId);
|
|
$segment = $this->entityManager->getReference(SegmentEntity::class, $segmentId);
|
|
|
|
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
|
|
$this->assertInstanceOf(SegmentEntity::class, $segment);
|
|
|
|
$newsletterSegment = new NewsletterSegmentEntity($newsletter, $segment);
|
|
|
|
$this->newsletterSegmentRepository->persist($newsletterSegment);
|
|
$this->newsletterSegmentRepository->flush();
|
|
|
|
return $newsletterSegment;
|
|
}
|
|
|
|
public function _createSubscriberSegment($subscriberId, $segmentId, $status = 'subscribed'): SubscriberSegmentEntity {
|
|
$subscriber = $this->entityManager->getReference(SubscriberEntity::class, $subscriberId);
|
|
$segment = $this->entityManager->getReference(SegmentEntity::class, $segmentId);
|
|
|
|
$this->assertInstanceOf(SubscriberEntity::class, $subscriber);
|
|
$this->assertInstanceOf(SegmentEntity::class, $segment);
|
|
|
|
return $this->subscriberSegmentRepository->createOrUpdate($subscriber, $segment, $status);
|
|
}
|
|
|
|
public function _createSegment(): SegmentEntity {
|
|
$segment = $this->segmentFactory
|
|
->withName('test')
|
|
->withType('default')
|
|
->create();
|
|
|
|
return $segment;
|
|
}
|
|
|
|
public function _createSubscriber($wpUserId = 0, $status = 'subscribed'): SubscriberEntity {
|
|
$subscriber = $this->subscriberFactory
|
|
->withEmail('john@doe.com')
|
|
->withFirstName('John')
|
|
->withLastName('Doe')
|
|
->withWpUserId($wpUserId)
|
|
->withStatus($status)
|
|
->create();
|
|
|
|
return $subscriber;
|
|
}
|
|
|
|
public function _createNewsletter($type = NewsletterEntity::TYPE_NOTIFICATION, $status = 'active'): NewsletterEntity {
|
|
$newsletter = $this->newsletterFactory
|
|
->withType($type)
|
|
->withStatus($status)
|
|
->create();
|
|
|
|
return $newsletter;
|
|
}
|
|
|
|
public function _createOrUpdateWPUser($role = null) {
|
|
$email = 'test@example.com';
|
|
$username = 'phoenix_test_user';
|
|
if (email_exists($email) === false) {
|
|
wp_insert_user(
|
|
[
|
|
'user_login' => $username,
|
|
'user_email' => $email,
|
|
'user_pass' => '',
|
|
]
|
|
);
|
|
}
|
|
$user = get_user_by('login', $username);
|
|
$this->assertInstanceOf(WP_User::class, $user);
|
|
wp_update_user(
|
|
[
|
|
'ID' => $user->ID,
|
|
'role' => $role,
|
|
]
|
|
);
|
|
verify($user->ID)->notNull();
|
|
return $user;
|
|
}
|
|
|
|
private function createTaskWithQueue(NewsletterEntity $newsletter): ScheduledTaskEntity {
|
|
$task = new ScheduledTaskEntity();
|
|
$queue = new SendingQueueEntity();
|
|
$task->setSendingQueue($queue);
|
|
$queue->setTask($task);
|
|
|
|
$task->setType(SendingQueue::TASK_TYPE);
|
|
$task->setStatus(SendingQueueEntity::STATUS_SCHEDULED);
|
|
$task->setScheduledAt(Carbon::now()->subDay());
|
|
$queue->setNewsletter($newsletter);
|
|
|
|
$this->entityManager->persist($task);
|
|
$this->entityManager->persist($queue);
|
|
$this->entityManager->flush();
|
|
return $task;
|
|
}
|
|
|
|
private function createTaskSubscriber(ScheduledTaskEntity $task, SubscriberEntity $subscriber): ScheduledTaskSubscriberEntity {
|
|
$scheduledTaskSubscriber = new ScheduledTaskSubscriberEntity($task, $subscriber);
|
|
$this->entityManager->persist($scheduledTaskSubscriber);
|
|
$task->getSubscribers()->add($scheduledTaskSubscriber);
|
|
if ($task->getSendingQueue()) {
|
|
$task->getSendingQueue()->setSubscribers((string)$subscriber->getId());
|
|
}
|
|
$this->entityManager->flush();
|
|
return $scheduledTaskSubscriber;
|
|
}
|
|
|
|
private function getScheduler(?SubscribersFinder $subscribersFinder = null): Scheduler {
|
|
$finder = $subscribersFinder ?: $this->makeEmpty(SubscribersFinder::class);
|
|
return $this->getServiceWithOverrides(
|
|
Scheduler::class,
|
|
['subscribersFinder' => $finder]
|
|
);
|
|
}
|
|
}
|