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

Refactor Cron to use logger_factory instance

Browse Source 
[MAILPOET-2444]
This commit is contained in:
Rostislav Wolny
2019-10-08 11:18:51 +02:00
committed by Jack Kitterhing
parent 9fbaa92c9b
commit e4262b0a6d
8 changed files with 130 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
lib/Cron/Workers/Scheduler.php
View File

@ -15,6 +15,7 @@ use MailPoet\Newsletter\Scheduler\Scheduler as NewsletterScheduler;
use MailPoet\Newsletter\Scheduler\WelcomeScheduler;
use MailPoet\Segments\SubscribersFinder;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoetVendor\Monolog\Logger;
class Scheduler {
const TASK_BATCH_SIZE = 5;
@ -24,11 +25,15 @@ class Scheduler {
/** @var SubscribersFinder */
private $subscribers_finder;
function __construct(SubscribersFinder $subscribers_finder, $timer = false) {
/** @var LoggerFactory */
private $logger_factory;
function __construct(SubscribersFinder $subscribers_finder, LoggerFactory $logger_factory, $timer = false) {
$this->timer = ($timer) ? $timer : microtime(true);
// abort if execution limit is reached
CronHelper::enforceExecutionLimit($this->timer);
$this->subscribers_finder = $subscribers_finder;
$this->logger_factory = $logger_factory;
}
function process() {
@ -78,14 +83,14 @@ class Scheduler {
}
function processPostNotificationNewsletter($newsletter, $queue) {
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'process post notification in scheduler',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
);
// ensure that segments exist
$segments = $newsletter->segments()->findMany();
if (empty($segments)) {
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'post notification no segments',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
);
@ -97,7 +102,7 @@ class Scheduler {
$subscribers_count = $this->subscribers_finder->addSubscribersToTaskFromSegments($queue->task(), $segments);
if (empty($subscribers_count)) {
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'post notification no subscribers',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
);
@ -114,7 +119,7 @@ class Scheduler {
$queue->save();
// update notification status
$notification_history->setStatus(Newsletter::STATUS_SENDING);
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'post notification set status to sending',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
);

25
lib/Cron/Workers/SendingQueue/SendingQueue.php
View File

@ -38,7 +38,17 @@ class SendingQueue {
/** @var MetaInfo */
private $mailerMetaInfo;
function __construct(SendingErrorHandler $error_handler, StatsNotificationsScheduler $stats_notifications_scheduler, $timer = false, $mailer_task = false, $newsletter_task = false) {
/** @var LoggerFactory */
private $logger_factory;
function __construct(
SendingErrorHandler $error_handler,
StatsNotificationsScheduler $stats_notifications_scheduler,
LoggerFactory $logger_factory,
$timer = false,
$mailer_task = false,
$newsletter_task = false
) {
$this->error_handler = $error_handler;
$this->stats_notifications_scheduler = $stats_notifications_scheduler;
$this->mailer_task = ($mailer_task) ? $mailer_task : new MailerTask();
@ -47,6 +57,7 @@ class SendingQueue {
$this->mailerMetaInfo = new MetaInfo;
$wp = new WPFunctions;
$this->batch_size = $wp->applyFilters('mailpoet_cron_worker_sending_queue_batch_size', self::BATCH_SIZE);
$this->logger_factory = $logger_factory;
}
function process() {
@ -55,7 +66,7 @@ class SendingQueue {
if (!$queue instanceof SendingTask) continue;
ScheduledTaskModel::touchAllByIds([$queue->task_id]);
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'sending queue processing',
['task_id' => $queue->task_id]
);
@ -66,7 +77,7 @@ class SendingQueue {
// pre-process newsletter (render, replace shortcodes/links, etc.)
$newsletter = $this->newsletter_task->preProcessNewsletter($newsletter, $queue);
if (!$newsletter) {
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'delete task in sending queue',
['task_id' => $queue->task_id]
);
@ -87,7 +98,7 @@ class SendingQueue {
// get subscribers
$subscriber_batches = new BatchIterator($queue->task_id, $this->batch_size);
foreach ($subscriber_batches as $subscribers_to_process_ids) {
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'subscriber batch processing',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id, 'subscriber_batch_count' => count($subscribers_to_process_ids)]
);
@ -118,7 +129,7 @@ class SendingQueue {
continue;
}
}
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'before queue chunk processing',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id, 'found_subscribers_count' => count($found_subscribers)]
);
@ -127,12 +138,12 @@ class SendingQueue {
$_newsletter,
$found_subscribers
);
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'after queue chunk processing',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
);
if ($queue->status === ScheduledTaskModel::STATUS_COMPLETED) {
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'completed newsletter sending',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
);

8
lib/Cron/Workers/SendingQueue/Tasks/Newsletter.php
View File

@ -26,6 +26,9 @@ class Newsletter {
/** @var PostsTask */
private $posts_task;
/** @var LoggerFactory */
private $logger_factory;
function __construct(WPFunctions $wp = null, PostsTask $posts_task = null) {
$settings = new SettingsController();
$this->tracking_enabled = (boolean)$settings->get('tracking.enabled');
@ -37,6 +40,7 @@ class Newsletter {
$posts_task = new PostsTask;
}
$this->posts_task = $posts_task;
$this->logger_factory = LoggerFactory::getInstance();
}
function getNewsletterFromQueue($queue) {
@ -74,7 +78,7 @@ class Newsletter {
$this->stopNewsletterPreProcessing(sprintf('QUEUE-%d-RENDER', $sending_task->id)) :
$newsletter;
}
LoggerFactory::getLogger('newsletters')->addInfo(
$this->logger_factory->getLogger('newsletters')->addInfo(
'pre-processing newsletter',
['newsletter_id' => $newsletter->id, 'task_id' => $sending_task->task_id]
);
@ -105,7 +109,7 @@ class Newsletter {
$this->posts_task->getAlcPostsCount($rendered_newsletter, $newsletter) === 0
) {
// delete notification history record since it will never be sent
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'no posts in post notification, deleting it',
['newsletter_id' => $newsletter->id, 'task_id' => $sending_task->task_id]
);

11
lib/Cron/Workers/SendingQueue/Tasks/Posts.php
View File

@ -7,11 +7,18 @@ use MailPoet\Models\Newsletter as NewsletterModel;
use MailPoet\Models\NewsletterPost;
class Posts {
/** @var LoggerFactory */
private $logger_factory;
public function __construct() {
$this->logger_factory = LoggerFactory::getInstance();
}
function extractAndSave($rendered_newsletter, $newsletter) {
if ($newsletter->type !== NewsletterModel::TYPE_NOTIFICATION_HISTORY) {
return false;
}
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'extract and save posts - before',
['newsletter_id' => $newsletter->id]
);
@ -30,7 +37,7 @@ class Posts {
$newsletter_post->post_id = $post_id;
$newsletter_post->save();
}
LoggerFactory::getLogger('post-notifications')->addInfo(
$this->logger_factory->getLogger('post-notifications')->addInfo(
'extract and save posts - after',
['newsletter_id' => $newsletter->id, 'matched_posts_ids' => $matched_posts_ids]
);

12
lib/Cron/Workers/WorkersFactory.php
View File

@ -14,6 +14,7 @@ use MailPoet\Cron\Workers\StatsNotifications\AutomatedEmails as StatsNotificatio
use MailPoet\Cron\Workers\StatsNotifications\Scheduler as StatsNotificationScheduler;
use MailPoet\Cron\Workers\StatsNotifications\Worker as StatsNotificationsWorker;
use MailPoet\Cron\Workers\WooCommerceSync as WooCommerceSyncWorker;
use MailPoet\Logging\LoggerFactory;
use MailPoet\Mailer\Mailer;
use MailPoet\Mailer\MetaInfo;
use MailPoet\Segments\SubscribersFinder;
@ -65,6 +66,9 @@ class WorkersFactory {
/** @var MetaInfo */
private $mailerMetaInfo;
/** @var LoggerFactory */
private $logger_factory;
public function __construct(
SendingErrorHandler $sending_error_handler,
StatsNotificationScheduler $statsNotificationsScheduler,
@ -77,7 +81,8 @@ class WorkersFactory {
WooCommercePurchases $woocommerce_purchases,
AuthorizedEmailsController $authorized_emails_controller,
SubscribersFinder $subscribers_finder,
MetaInfo $mailerMetaInfo
MetaInfo $mailerMetaInfo,
LoggerFactory $logger_factory
) {
$this->sending_error_handler = $sending_error_handler;
$this->statsNotificationsScheduler = $statsNotificationsScheduler;
@ -91,16 +96,17 @@ class WorkersFactory {
$this->authorized_emails_controller = $authorized_emails_controller;
$this->subscribers_finder = $subscribers_finder;
$this->mailerMetaInfo = $mailerMetaInfo;
$this->logger_factory = $logger_factory;
}
/** @return SchedulerWorker */
function createScheduleWorker($timer) {
return new SchedulerWorker($this->subscribers_finder, $timer);
return new SchedulerWorker($this->subscribers_finder, $this->logger_factory, $timer);
}
/** @return SendingQueueWorker */
function createQueueWorker($timer) {
return new SendingQueueWorker($this->sending_error_handler, $this->statsNotificationsScheduler, $timer);
return new SendingQueueWorker($this->sending_error_handler, $this->statsNotificationsScheduler, $this->logger_factory, $timer);
}
/** @return StatsNotificationsWorker */

66
tests/integration/Cron/Workers/SchedulerTest.php
View File

@ -7,6 +7,7 @@ use Codeception\Stub;
use Codeception\Stub\Expected;
use MailPoet\Cron\CronHelper;
use MailPoet\Cron\Workers\Scheduler;
use MailPoet\Logging\LoggerFactory;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
@ -23,17 +24,25 @@ use MailPoet\Segments\SubscribersFinder;
use MailPoet\Tasks\Sending as SendingTask;
class SchedulerTest extends \MailPoetTest {
/** @var LoggerFactory */
private $logger_factory;
function _before() {
parent::_before();
$this->logger_factory = LoggerFactory::getInstance();
}
function testItConstructs() {
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
expect($scheduler->timer)->greaterOrEquals(5);
$timer = microtime(true) - 2;
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $timer);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $timer);
expect($scheduler->timer)->equals($timer);
}
function testItThrowsExceptionWhenExecutionLimitIsReached() {
try {
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), microtime(true) - CronHelper::getDaemonExecutionLimit());
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, microtime(true) - CronHelper::getDaemonExecutionLimit());
self::fail('Maximum execution time limit exception was not thrown.');
} catch (\Exception $e) {
expect($e->getMessage())->equals('Maximum execution time has been reached.');
@ -62,7 +71,7 @@ class SchedulerTest extends \MailPoetTest {
expect($notification_history)->isEmpty();
// create notification history and ensure that it exists
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$scheduler->createNotificationHistory($newsletter->id);
$notification_history = Newsletter::where('type', Newsletter::TYPE_NOTIFICATION_HISTORY)
->where('parent_id', $newsletter->id)
@ -78,7 +87,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// queue and associated newsletter should be deleted when interval type is set to "immediately"
expect(SendingQueue::findMany())->notEmpty();
@ -94,7 +103,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// queue's next run date should change when interval type is set to anything
// other than "immediately"
@ -124,7 +133,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return false and delete queue when subscriber is not a WP user
$result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@ -147,7 +156,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return false and delete queue when subscriber role is different from the one
// specified for the welcome email
@ -169,7 +178,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return true when user exists and WP role matches the one specified for the welcome email
$result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@ -190,7 +199,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// true when user exists and has any role
$result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@ -204,7 +213,7 @@ class SchedulerTest extends \MailPoetTest {
$queue->setSubscribers([]);
// delete queue when the list of subscribers to process is blank
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$result = $scheduler->processWelcomeNewsletter($newsletter, $queue);
expect($result)->false();
expect(SendingQueue::findMany())->count(0);
@ -274,7 +283,7 @@ class SchedulerTest extends \MailPoetTest {
}
function testItFailsMailpoetSubscriberVerificationWhenSubscriberDoesNotExist() {
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$newsletter = $this->_createNewsletter();
$queue = $this->_createQueue($newsletter->id);
@ -294,7 +303,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return false
$result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@ -319,7 +328,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return false
$result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@ -348,7 +357,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return false
$result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@ -371,7 +380,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
// return true after successful verification
$result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@ -393,7 +402,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$queue = $this->_createQueue($newsletter->id);
$scheduler = new Scheduler(new SubscribersFinder());
$scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
// return true
expect($scheduler->processScheduledStandardNewsletter($newsletter, $queue))->true();
@ -417,6 +426,7 @@ class SchedulerTest extends \MailPoetTest {
'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
return false;
}),
'logger_factory' => $this->logger_factory,
], $this);
expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->false();
}
@ -428,7 +438,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter_segment = $this->_createNewsletterSegment($newsletter->id, $segment->id);
// delete or reschedule queue when there are no subscribers in segments
$scheduler = $this->construct(Scheduler::class, [new SubscribersFinder()], [
$scheduler = $this->construct(Scheduler::class, [new SubscribersFinder(), $this->logger_factory], [
'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
return false;
}),
@ -451,7 +461,7 @@ class SchedulerTest extends \MailPoetTest {
);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
$scheduler = new Scheduler(new SubscribersFinder());
$scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
// return true
expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->true();
@ -472,7 +482,7 @@ class SchedulerTest extends \MailPoetTest {
}
function testItFailsToProcessWhenScheduledQueuesNotFound() {
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
expect($scheduler->process())->false();
}
@ -480,7 +490,7 @@ class SchedulerTest extends \MailPoetTest {
$queue = $this->_createQueue(1);
$queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
$queue->save();
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$scheduler->process();
expect(SendingQueue::findMany())->count(0);
}
@ -492,7 +502,7 @@ class SchedulerTest extends \MailPoetTest {
$queue = $this->_createQueue($newsletter->id);
$queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
$queue->save();
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$scheduler->process();
expect(SendingQueue::findMany())->count(0);
}
@ -587,7 +597,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = $this->_createNewsletter(Newsletter::TYPE_STANDARD, Newsletter::STATUS_DRAFT);
$queue = $this->_createQueue($newsletter->id);
$finder = $this->makeEmpty(SubscribersFinder::class);
$scheduler = new Scheduler($finder);
$scheduler = new Scheduler($finder, $this->logger_factory);
$scheduler->processScheduledStandardNewsletter($newsletter, $queue);
$refetched_task = ScheduledTask::where('id', $task->id)->findOne();
@ -603,7 +613,7 @@ class SchedulerTest extends \MailPoetTest {
$newsletter = $this->_createNewsletter(Newsletter::TYPE_STANDARD, Newsletter::STATUS_DRAFT);
$queue = $this->_createQueue($newsletter->id);
$finder = $this->makeEmpty(SubscribersFinder::class);
$scheduler = new Scheduler($finder);
$scheduler = new Scheduler($finder, $this->logger_factory);
$scheduler->processScheduledStandardNewsletter($newsletter, $queue);
$refetched_task = ScheduledTask::where('id', $task->id)->findOne();
@ -641,7 +651,7 @@ class SchedulerTest extends \MailPoetTest {
expect($task->getSubscribers())->equals([$subscriber->id]);
// task should have its status set to null (i.e., sending)
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id);
expect($task->status)->null();
@ -665,7 +675,7 @@ class SchedulerTest extends \MailPoetTest {
expect($task->getSubscribers())->equals([$subscriber->id]);
// task should be deleted
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id);
expect($task)->false();
@ -693,7 +703,7 @@ class SchedulerTest extends \MailPoetTest {
expect($task->newsletter_id)->equals($newsletter->id);
// task should have its status set to null (i.e., sending)
$scheduler = new Scheduler(new SubscribersFinder());
$scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
$scheduler->process();
$task = SendingTask::getByNewsletterId($newsletter->id);
expect($task->status)->null();
@ -710,7 +720,7 @@ class SchedulerTest extends \MailPoetTest {
$queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
$queue->updated_at = $originalUpdated;
$queue->save();
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
$scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
$scheduler->timer = microtime(true);
$scheduler->process();
$newQueue = ScheduledTask::findOne($queue->task_id);

44
tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php
View File

@ -13,6 +13,7 @@ use MailPoet\Cron\Workers\SendingQueue\Tasks\Mailer as MailerTask;
use MailPoet\Cron\Workers\SendingQueue\Tasks\Newsletter as NewsletterTask;
use MailPoet\Cron\Workers\StatsNotifications\Scheduler as StatsNotificationsScheduler;
use MailPoet\Features\FeaturesController;
use MailPoet\Logging\LoggerFactory;
use MailPoet\Mailer\MailerLog;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterLink;
@ -45,6 +46,8 @@ class SendingQueueTest extends \MailPoetTest {
private $settings;
/** @var Scheduler */
private $stats_notifications_worker;
/** @var LoggerFactory */
private $logger_factory;
function _before() {
parent::_before();
@ -93,7 +96,8 @@ class SendingQueueTest extends \MailPoetTest {
$this->newsletter_link->save();
$this->sending_error_handler = new SendingErrorHandler();
$this->stats_notifications_worker = new StatsNotificationsScheduler($this->settings);
$this->sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker);
$this->logger_factory = LoggerFactory::getInstance();
$this->sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory);
}
private function getDirectUnsubscribeURL() {
@ -124,20 +128,20 @@ class SendingQueueTest extends \MailPoetTest {
// constructor accepts timer argument
$timer = microtime(true) - 5;
$sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $timer);
$sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, $timer);
expect($sending_queue_worker->timer)->equals($timer);
}
function testItEnforcesExecutionLimitsBeforeQueueProcessing() {
$sending_queue_worker = Stub::make(
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
[
'processQueue' => Expected::never(),
'enforceSendingAndExecutionLimits' => Expected::exactly(1, function() {
throw new \Exception();
}),
], $this);
$sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker);
$sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory);
try {
$sending_queue_worker->process();
self::fail('Execution limits function was not called.');
@ -148,13 +152,14 @@ class SendingQueueTest extends \MailPoetTest {
function testItEnforcesExecutionLimitsAfterSendingWhenQueueStatusIsNotSetToComplete() {
$sending_queue_worker = Stub::make(
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
[
'enforceSendingAndExecutionLimits' => Expected::exactly(1),
], $this);
$sending_queue_worker->__construct(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -183,13 +188,14 @@ class SendingQueueTest extends \MailPoetTest {
$queue = $this->queue;
$queue->status = SendingQueue::STATUS_COMPLETED;
$sending_queue_worker = Stub::make(
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
[
'enforceSendingAndExecutionLimits' => Expected::never(),
], $this);
$sending_queue_worker->__construct(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -213,7 +219,7 @@ class SendingQueueTest extends \MailPoetTest {
function testItEnforcesExecutionLimitsAfterQueueProcessing() {
$sending_queue_worker = Stub::make(
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
[
'processQueue' => function() {
// this function returns a queue object
@ -221,7 +227,7 @@ class SendingQueueTest extends \MailPoetTest {
},
'enforceSendingAndExecutionLimits' => Expected::exactly(2),
], $this);
$sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker);
$sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory);
$sending_queue_worker->process();
}
@ -246,6 +252,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -274,6 +281,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -300,6 +308,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -345,6 +354,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -393,6 +403,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -448,6 +459,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::makeEmpty(new MailerTask(), [], $this)
);
@ -464,6 +476,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -514,6 +527,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -676,10 +690,15 @@ class SendingQueueTest extends \MailPoetTest {
->method('__get')
->with('id')
->will($this->returnValue(100));
$sending_queue_worker = Stub::make(new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker));
$sending_queue_worker = Stub::make(new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory
));
$sending_queue_worker->__construct(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -714,6 +733,7 @@ class SendingQueueTest extends \MailPoetTest {
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory,
$timer = false,
Stub::make(
new MailerTask(),
@ -738,7 +758,11 @@ class SendingQueueTest extends \MailPoetTest {
};
$wp = new WPFunctions;
$wp->addFilter('mailpoet_cron_worker_sending_queue_batch_size', $filter);
$sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker);
$sending_queue_worker = new SendingQueueWorker(
$this->sending_error_handler,
$this->stats_notifications_worker,
$this->logger_factory
);
expect($sending_queue_worker->batch_size)->equals($custom_batch_size_value);
$wp->removeFilter('mailpoet_cron_worker_sending_queue_batch_size', $filter);
}

6
tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
View File

@ -7,6 +7,7 @@ use Codeception\Util\Fixtures;
use Helper\WordPressHooks as WPHooksHelper;
use MailPoet\Cron\Workers\SendingQueue\Tasks\Newsletter as NewsletterTask;
use MailPoet\Cron\Workers\SendingQueue\Tasks\Posts as PostsTask;
use MailPoet\Logging\LoggerFactory;
use MailPoet\Mailer\MailerLog;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterLink;
@ -36,6 +37,9 @@ class NewsletterTest extends \MailPoetTest {
/** @var SendingTask */
private $queue;
/** @var LoggerFactory */
private $logger_factory;
function _before() {
parent::_before();
$this->newsletter_task = new NewsletterTask();
@ -61,6 +65,7 @@ class NewsletterTest extends \MailPoetTest {
$this->queue = SendingTask::create();
$this->queue->newsletter_id = $this->newsletter->id;
$this->queue->save();
$this->logger_factory = LoggerFactory::getInstance();
}
function testItConstructs() {
@ -208,6 +213,7 @@ class NewsletterTest extends \MailPoetTest {
$this->newsletter->parent_id = $this->newsletter->id;
$posts_task = $this->make(PostsTask::class, [
'getAlcPostsCount' => 1,
'logger_factory' => $this->logger_factory,
]);
$newsletter_task = new NewsletterTask(new WPFunctions, $posts_task);
$result = $newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);