diff --git a/lib/Cron/Workers/Bounce.php b/lib/Cron/Workers/Bounce.php
index ab97912582..fc8d8219d6 100644
--- a/lib/Cron/Workers/Bounce.php
+++ b/lib/Cron/Workers/Bounce.php
@@ -59,7 +59,7 @@ class Bounce extends SimpleWorker {
 
     foreach ($subscriber_batches as $subscribers_to_process_ids) {
       // abort if execution limit is reached
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
 
       $subscriber_emails = Subscriber::select('email')
         ->whereIn('id', $subscribers_to_process_ids)
diff --git a/lib/Cron/Workers/InactiveSubscribers.php b/lib/Cron/Workers/InactiveSubscribers.php
index 525e648ab0..60c1b865b3 100644
--- a/lib/Cron/Workers/InactiveSubscribers.php
+++ b/lib/Cron/Workers/InactiveSubscribers.php
@@ -55,10 +55,10 @@ class InactiveSubscribers extends SimpleWorker {
       $last_subscriber_id += self::BATCH_SIZE;
       $task->meta = ['last_subscriber_id' => $last_subscriber_id];
       $task->save();
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
     };
     while ($this->inactive_subscribers_controller->markActiveSubscribers($days_to_inactive, self::BATCH_SIZE) === self::BATCH_SIZE) {
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
     };
     self::schedule();
     return true;
diff --git a/lib/Cron/Workers/Scheduler.php b/lib/Cron/Workers/Scheduler.php
index 03074482a9..44c41bb816 100644
--- a/lib/Cron/Workers/Scheduler.php
+++ b/lib/Cron/Workers/Scheduler.php
@@ -28,10 +28,19 @@ class Scheduler {
   /** @var LoggerFactory */
   private $logger_factory;
 
-  function __construct(SubscribersFinder $subscribers_finder, LoggerFactory $logger_factory, $timer = false) {
+  /** @var CronHelper */
+  private $cron_helper;
+
+  function __construct(
+    SubscribersFinder $subscribers_finder,
+    LoggerFactory $logger_factory,
+    CronHelper $cron_helper,
+    $timer = false
+  ) {
     $this->timer = ($timer) ? $timer : microtime(true);
     // abort if execution limit is reached
-    CronHelper::enforceExecutionLimit($this->timer);
+    $this->cron_helper = $cron_helper;
+    $this->cron_helper->enforceExecutionLimit($this->timer);
     $this->subscribers_finder = $subscribers_finder;
     $this->logger_factory = $logger_factory;
   }
@@ -55,7 +64,7 @@ class Scheduler {
       } elseif ($newsletter->type === Newsletter::TYPE_AUTOMATIC) {
         $this->processScheduledAutomaticEmail($newsletter, $queue);
       }
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
     }
   }
 
diff --git a/lib/Cron/Workers/SendingQueue/Migration.php b/lib/Cron/Workers/SendingQueue/Migration.php
index 7319d895ad..073df2de61 100644
--- a/lib/Cron/Workers/SendingQueue/Migration.php
+++ b/lib/Cron/Workers/SendingQueue/Migration.php
@@ -132,7 +132,7 @@ class Migration extends SimpleWorker {
     if (!empty($queues)) {
       foreach (array_chunk($queues, self::BATCH_SIZE) as $queue_batch) {
         // abort if execution limit is reached
-        CronHelper::enforceExecutionLimit($this->timer);
+        $this->cron_helper->enforceExecutionLimit($this->timer);
 
         foreach ($queue_batch as $queue) {
           // create a new scheduled task of type "sending"
@@ -181,7 +181,7 @@ class Migration extends SimpleWorker {
     if (!empty($task_ids)) {
       foreach ($task_ids as $task_id) {
         // abort if execution limit is reached
-        CronHelper::enforceExecutionLimit($this->timer);
+        $this->cron_helper->enforceExecutionLimit($this->timer);
 
         $this->migrateTaskSubscribers($task_id);
       }
@@ -216,7 +216,7 @@ class Migration extends SimpleWorker {
       $subscribers_to_migrate = array_slice($subscribers['to_process'], $migrated_unprocessed_count);
       foreach ($subscribers_to_migrate as $sub_id) {
         // abort if execution limit is reached
-        CronHelper::enforceExecutionLimit($this->timer);
+        $this->cron_helper->enforceExecutionLimit($this->timer);
 
         ScheduledTaskSubscriber::createOrUpdate([
           'task_id' => $task_id,
@@ -230,7 +230,7 @@ class Migration extends SimpleWorker {
       $subscribers_to_migrate = array_slice($subscribers['processed'], $migrated_processed_count);
       foreach ($subscribers_to_migrate as $sub_id) {
         // abort if execution limit is reached
-        CronHelper::enforceExecutionLimit($this->timer);
+        $this->cron_helper->enforceExecutionLimit($this->timer);
 
         ScheduledTaskSubscriber::createOrUpdate([
           'task_id' => $task_id,
diff --git a/lib/Cron/Workers/SendingQueue/SendingQueue.php b/lib/Cron/Workers/SendingQueue/SendingQueue.php
index 6a9a1e0e4b..60283f2e7f 100644
--- a/lib/Cron/Workers/SendingQueue/SendingQueue.php
+++ b/lib/Cron/Workers/SendingQueue/SendingQueue.php
@@ -45,11 +45,15 @@ class SendingQueue {
   /** @var NewslettersRepository */
   private $newsletters_repository;
 
+  /** @var CronHelper */
+  private $cron_helper;
+
   function __construct(
     SendingErrorHandler $error_handler,
     StatsNotificationsScheduler $stats_notifications_scheduler,
     LoggerFactory $logger_factory,
     NewslettersRepository $newsletters_repository,
+    CronHelper $cron_helper,
     $timer = false,
     $mailer_task = false,
     $newsletter_task = false
@@ -64,6 +68,7 @@ class SendingQueue {
     $this->batch_size = $wp->applyFilters('mailpoet_cron_worker_sending_queue_batch_size', self::BATCH_SIZE);
     $this->logger_factory = $logger_factory;
     $this->newsletters_repository = $newsletters_repository;
+    $this->cron_helper = $cron_helper;
   }
 
   function process() {
@@ -294,7 +299,7 @@ class SendingQueue {
 
   function enforceSendingAndExecutionLimits() {
     // abort if execution limit is reached
-    CronHelper::enforceExecutionLimit($this->timer);
+    $this->cron_helper->enforceExecutionLimit($this->timer);
     // abort if sending limit has been reached
     MailerLog::enforceExecutionRequirements();
   }
diff --git a/lib/Cron/Workers/SimpleWorker.php b/lib/Cron/Workers/SimpleWorker.php
index f1f8baf95b..c797d2866d 100644
--- a/lib/Cron/Workers/SimpleWorker.php
+++ b/lib/Cron/Workers/SimpleWorker.php
@@ -4,6 +4,7 @@ namespace MailPoet\Cron\Workers;
 
 use Carbon\Carbon;
 use MailPoet\Cron\CronHelper;
+use MailPoet\DI\ContainerWrapper;
 use MailPoet\Models\ScheduledTask;
 use MailPoet\WP\Functions as WPFunctions;
 
@@ -18,13 +19,17 @@ abstract class SimpleWorker {
   const TASK_RUN_TIMEOUT = 120;
   const TIMED_OUT_TASK_RESCHEDULE_TIMEOUT = 5;
 
+  /** @var CronHelper */
+  protected $cron_helper;
+
   function __construct($timer = false) {
     if (static::TASK_TYPE === null) {
       throw new \Exception('Constant TASK_TYPE is not defined on subclass ' . get_class($this));
     }
     $this->timer = ($timer) ? $timer : microtime(true);
     // abort if execution limit is reached
-    CronHelper::enforceExecutionLimit($this->timer);
+    $this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
+    $this->cron_helper->enforceExecutionLimit($this->timer);
     $this->wp = new WPFunctions();
   }
 
@@ -92,14 +97,14 @@ abstract class SimpleWorker {
     $task->save();
 
     // abort if execution limit is reached
-    CronHelper::enforceExecutionLimit($this->timer);
+    $this->cron_helper->enforceExecutionLimit($this->timer);
 
     return true;
   }
 
   function processTask(ScheduledTask $task) {
     // abort if execution limit is reached
-    CronHelper::enforceExecutionLimit($this->timer);
+    $this->cron_helper->enforceExecutionLimit($this->timer);
 
     if (!static::SUPPORT_MULTIPLE_INSTANCES) {
       if ($this->rescheduleOutdated($task)) {
diff --git a/lib/Cron/Workers/StatsNotifications/Worker.php b/lib/Cron/Workers/StatsNotifications/Worker.php
index 2aa5ef0f14..b7081770ba 100644
--- a/lib/Cron/Workers/StatsNotifications/Worker.php
+++ b/lib/Cron/Workers/StatsNotifications/Worker.php
@@ -36,6 +36,9 @@ class Worker {
   /** @var SettingsController */
   private $settings;
 
+  /** @var CronHelper */
+  private $cron_helper;
+
   /** @var MetaInfo */
   private $mailerMetaInfo;
 
@@ -55,6 +58,7 @@ class Worker {
     Mailer $mailer,
     Renderer $renderer,
     SettingsController $settings,
+    CronHelper $cron_helper,
     MetaInfo $mailerMetaInfo,
     StatsNotificationsRepository $repository,
     NewsletterLinkRepository $newsletter_link_repository,
@@ -66,6 +70,7 @@ class Worker {
     $this->renderer = $renderer;
     $this->mailer = $mailer;
     $this->settings = $settings;
+    $this->cron_helper = $cron_helper;
     $this->mailerMetaInfo = $mailerMetaInfo;
     $this->repository = $repository;
     $this->entity_manager = $entity_manager;
@@ -89,7 +94,7 @@ class Worker {
       } finally {
         $this->markTaskAsFinished($stats_notification_entity->getTask());
       }
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
     }
   }
 
diff --git a/lib/Cron/Workers/UnsubscribeTokens.php b/lib/Cron/Workers/UnsubscribeTokens.php
index aec8633f03..ab2791528b 100644
--- a/lib/Cron/Workers/UnsubscribeTokens.php
+++ b/lib/Cron/Workers/UnsubscribeTokens.php
@@ -18,13 +18,13 @@ class UnsubscribeTokens extends SimpleWorker {
   function processTaskStrategy(ScheduledTask $task) {
     $meta = $task->getMeta();
     do {
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
       $subscribers_count = $this->addTokens(Subscriber::class, $meta['last_subscriber_id']);
       $task->meta = $meta;
       $task->save();
     } while ($subscribers_count === self::BATCH_SIZE);
     do {
-      CronHelper::enforceExecutionLimit($this->timer);
+      $this->cron_helper->enforceExecutionLimit($this->timer);
       $newsletters_count = $this->addTokens(Newsletter::class, $meta['last_newsletter_id']);
       $task->meta = $meta;
       $task->save();
diff --git a/lib/Cron/Workers/WorkersFactory.php b/lib/Cron/Workers/WorkersFactory.php
index 98437822fc..fff76fc479 100644
--- a/lib/Cron/Workers/WorkersFactory.php
+++ b/lib/Cron/Workers/WorkersFactory.php
@@ -3,6 +3,7 @@
 namespace MailPoet\Cron\Workers;
 
 use MailPoet\Config\Renderer;
+use MailPoet\Cron\CronHelper;
 use MailPoet\Cron\Workers\Bounce as BounceWorker;
 use MailPoet\Cron\Workers\KeyCheck\PremiumKeyCheck as PremiumKeyCheckWorker;
 use MailPoet\Cron\Workers\KeyCheck\SendingServiceKeyCheck as SendingServiceKeyCheckWorker;
@@ -45,6 +46,9 @@ class WorkersFactory {
   /** @var SettingsController */
   private $settings;
 
+  /** @var CronHelper */
+  private $cron_helper;
+
   /** @var WooCommerceSegment */
   private $woocommerce_segment;
 
@@ -95,6 +99,7 @@ class WorkersFactory {
     Mailer $mailer,
     Renderer $renderer,
     SettingsController $settings,
+    CronHelper $cron_helper,
     WooCommerceSegment $woocommerce_segment,
     InactiveSubscribersController $inactive_subscribers_controller,
     WooCommerceHelper $woocommerce_helper,
@@ -114,6 +119,7 @@ class WorkersFactory {
     $this->mailer = $mailer;
     $this->renderer = $renderer;
     $this->settings = $settings;
+    $this->cron_helper = $cron_helper;
     $this->woocommerce_segment = $woocommerce_segment;
     $this->inactive_subscribers_controller = $inactive_subscribers_controller;
     $this->woocommerce_helper = $woocommerce_helper;
@@ -131,7 +137,7 @@ class WorkersFactory {
 
   /** @return SchedulerWorker */
   function createScheduleWorker($timer) {
-    return new SchedulerWorker($this->subscribers_finder, $this->logger_factory, $timer);
+    return new SchedulerWorker($this->subscribers_finder, $this->logger_factory, $this->cron_helper, $timer);
   }
 
   /** @return SendingQueueWorker */
@@ -141,6 +147,7 @@ class WorkersFactory {
       $this->statsNotificationsScheduler,
       $this->logger_factory,
       $this->newsletters_repository,
+      $this->cron_helper,
       $timer
     );
   }
@@ -151,6 +158,7 @@ class WorkersFactory {
       $this->mailer,
       $this->renderer,
       $this->settings,
+      $this->cron_helper,
       $this->mailerMetaInfo,
       $this->stats_notifications_repository,
       $this->newsletter_link_repository,
diff --git a/tests/integration/Cron/Workers/InactiveSubscribersTest.php b/tests/integration/Cron/Workers/InactiveSubscribersTest.php
index 1753109689..d2d9f44814 100644
--- a/tests/integration/Cron/Workers/InactiveSubscribersTest.php
+++ b/tests/integration/Cron/Workers/InactiveSubscribersTest.php
@@ -6,6 +6,7 @@ use Carbon\Carbon;
 use Codeception\Stub;
 use MailPoet\Cron\CronHelper;
 use MailPoet\Cron\Workers\InactiveSubscribers;
+use MailPoet\DI\ContainerWrapper;
 use MailPoet\Models\ScheduledTask;
 use MailPoet\Settings\SettingsController;
 use MailPoet\Subscribers\InactiveSubscribersController;
@@ -19,6 +20,7 @@ class InactiveSubscribersTest extends \MailPoetTest {
     $this->settings = new SettingsController();
     \ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
     $this->settings->set('tracking.enabled', true);
+    $this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
     parent::_before();
   }
 
@@ -115,7 +117,7 @@ class InactiveSubscribersTest extends \MailPoetTest {
       'reactivateInactiveSubscribers' => Stub\Expected::never(),
     ], $this);
 
-    $worker = new InactiveSubscribers($controller_mock, $this->settings, microtime(true) - (CronHelper::getDaemonExecutionLimit() - 1));
+    $worker = new InactiveSubscribers($controller_mock, $this->settings, microtime(true) - ($this->cron_helper->getDaemonExecutionLimit() - 1));
     sleep(1);
     $this->setExpectedException(\Exception::class, 'Maximum execution time has been reached.');
     $worker->processTaskStrategy(ScheduledTask::createOrUpdate([]));
diff --git a/tests/integration/Cron/Workers/SchedulerTest.php b/tests/integration/Cron/Workers/SchedulerTest.php
index 1be2cceca4..4553894a75 100644
--- a/tests/integration/Cron/Workers/SchedulerTest.php
+++ b/tests/integration/Cron/Workers/SchedulerTest.php
@@ -7,6 +7,7 @@ use Codeception\Stub;
 use Codeception\Stub\Expected;
 use MailPoet\Cron\CronHelper;
 use MailPoet\Cron\Workers\Scheduler;
+use MailPoet\DI\ContainerWrapper;
 use MailPoet\Logging\LoggerFactory;
 use MailPoet\Models\Newsletter;
 use MailPoet\Models\NewsletterOption;
@@ -30,19 +31,20 @@ class SchedulerTest extends \MailPoetTest {
   function _before() {
     parent::_before();
     $this->logger_factory = LoggerFactory::getInstance();
+    $this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
   }
 
   function testItConstructs() {
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     expect($scheduler->timer)->greaterOrEquals(5);
     $timer = microtime(true) - 2;
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $timer);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper, $timer);
     expect($scheduler->timer)->equals($timer);
   }
 
   function testItThrowsExceptionWhenExecutionLimitIsReached() {
     try {
-      $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, microtime(true) - CronHelper::getDaemonExecutionLimit());
+      $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper, microtime(true) - $this->cron_helper->getDaemonExecutionLimit());
       self::fail('Maximum execution time limit exception was not thrown.');
     } catch (\Exception $e) {
       expect($e->getMessage())->equals('Maximum execution time has been reached.');
@@ -71,7 +73,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($notification_history)->isEmpty();
 
     // create notification history and ensure that it exists
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $scheduler->createNotificationHistory($newsletter->id);
     $notification_history = Newsletter::where('type', Newsletter::TYPE_NOTIFICATION_HISTORY)
       ->where('parent_id', $newsletter->id)
@@ -87,7 +89,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // queue and associated newsletter should be deleted when interval type is set to "immediately"
     expect(SendingQueue::findMany())->notEmpty();
@@ -103,7 +105,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // queue's next run date should change when interval type is set to anything
     // other than "immediately"
@@ -133,7 +135,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return false and delete queue when subscriber is not a WP user
     $result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@@ -156,7 +158,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return false and delete queue when subscriber role is different from the one
     // specified for the welcome email
@@ -178,7 +180,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return true when user exists and WP role matches the one specified for the welcome email
     $result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@@ -199,7 +201,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // true when user exists and has any role
     $result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@@ -213,7 +215,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $result = $scheduler->processWelcomeNewsletter($newsletter, $queue);
     expect($result)->false();
     expect(SendingQueue::findMany())->count(0);
@@ -283,7 +285,7 @@ class SchedulerTest extends \MailPoetTest {
   }
 
   function testItFailsMailpoetSubscriberVerificationWhenSubscriberDoesNotExist() {
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $newsletter = $this->_createNewsletter();
     $queue = $this->_createQueue($newsletter->id);
 
@@ -303,7 +305,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return false
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -328,7 +330,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return false
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -357,7 +359,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return false
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -380,7 +382,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
 
     // return true after successful verification
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -402,7 +404,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(), $this->logger_factory);
+    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory, $this->cron_helper);
 
     // return true
     expect($scheduler->processScheduledStandardNewsletter($newsletter, $queue))->true();
@@ -427,6 +429,7 @@ class SchedulerTest extends \MailPoetTest {
         return false;
       }),
       'logger_factory' => $this->logger_factory,
+      'cron_helper' => $this->cron_helper,
     ], $this);
     expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->false();
   }
@@ -438,7 +441,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(), $this->logger_factory], [
+    $scheduler = $this->construct(Scheduler::class, [new SubscribersFinder(), $this->logger_factory, $this->cron_helper], [
       'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
         return false;
       }),
@@ -461,7 +464,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
-    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
+    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory, $this->cron_helper);
 
     // return true
     expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->true();
@@ -482,7 +485,7 @@ class SchedulerTest extends \MailPoetTest {
   }
 
   function testItFailsToProcessWhenScheduledQueuesNotFound() {
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     expect($scheduler->process())->false();
   }
 
@@ -490,7 +493,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $scheduler->process();
     expect(SendingQueue::findMany())->count(0);
   }
@@ -502,7 +505,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $scheduler->process();
     expect(SendingQueue::findMany())->count(0);
   }
@@ -514,6 +517,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue->save();
     $scheduler = Stub::make(Scheduler::class, [
       'processWelcomeNewsletter' => Expected::exactly(1),
+      'cron_helper' => $this->cron_helper,
     ], $this);
     $scheduler->timer = microtime(true);
     $scheduler->process();
@@ -526,6 +530,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue->save();
     $scheduler = Stub::make(Scheduler::class, [
       'processPostNotificationNewsletter' => Expected::exactly(1),
+      'cron_helper' => $this->cron_helper,
     ], $this);
     $scheduler->timer = microtime(true);
     $scheduler->process();
@@ -538,6 +543,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue->save();
     $scheduler = Stub::make(Scheduler::class, [
       'processScheduledStandardNewsletter' => Expected::exactly(1),
+      'cron_helper' => $this->cron_helper,
     ], $this);
     $scheduler->timer = microtime(true);
     $scheduler->process();
@@ -550,8 +556,9 @@ class SchedulerTest extends \MailPoetTest {
     $queue->save();
     $scheduler = Stub::make(Scheduler::class, [
       'processPostNotificationNewsletter' => Expected::exactly(1),
+      'cron_helper' => $this->cron_helper,
     ], $this);
-    $scheduler->timer = microtime(true) - CronHelper::getDaemonExecutionLimit();
+    $scheduler->timer = microtime(true) - $this->cron_helper->getDaemonExecutionLimit();
     try {
       $scheduler->process();
       self::fail('Maximum execution time limit exception was not thrown.');
@@ -568,6 +575,7 @@ class SchedulerTest extends \MailPoetTest {
 
     $scheduler = Stub::make(Scheduler::class, [
       'processScheduledStandardNewsletter' => Expected::never(),
+      'cron_helper' => $this->cron_helper,
     ], $this);
     // scheduled job is not processed
     $scheduler->timer = microtime(true);
@@ -582,6 +590,7 @@ class SchedulerTest extends \MailPoetTest {
 
     $scheduler = Stub::make(Scheduler::class, [
       'processScheduledStandardNewsletter' => Expected::once(),
+      'cron_helper' => $this->cron_helper,
     ], $this);
     // scheduled job is processed
     $scheduler->timer = microtime(true);
@@ -597,7 +606,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, $this->logger_factory);
+    $scheduler = new Scheduler($finder, $this->logger_factory, $this->cron_helper);
 
     $scheduler->processScheduledStandardNewsletter($newsletter, $queue);
     $refetched_task = ScheduledTask::where('id', $task->id)->findOne();
@@ -613,7 +622,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, $this->logger_factory);
+    $scheduler = new Scheduler($finder, $this->logger_factory, $this->cron_helper);
 
     $scheduler->processScheduledStandardNewsletter($newsletter, $queue);
     $refetched_task = ScheduledTask::where('id', $task->id)->findOne();
@@ -628,6 +637,7 @@ class SchedulerTest extends \MailPoetTest {
 
     $scheduler = Stub::make(Scheduler::class, [
       'processScheduledStandardNewsletter' => Expected::once(),
+      'cron_helper' => $this->cron_helper,
     ], $this);
     // scheduled job is processed
     $scheduler->timer = microtime(true);
@@ -651,7 +661,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $scheduler->process();
     $task = SendingTask::getByNewsletterId($newsletter->id);
     expect($task->status)->null();
@@ -675,7 +685,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($task->getSubscribers())->equals([$subscriber->id]);
 
     // task should be deleted
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $scheduler->process();
     $task = SendingTask::getByNewsletterId($newsletter->id);
     expect($task)->false();
@@ -703,7 +713,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(), $this->logger_factory);
+    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory, $this->cron_helper);
     $scheduler->process();
     $task = SendingTask::getByNewsletterId($newsletter->id);
     expect($task->status)->null();
@@ -720,7 +730,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), $this->logger_factory);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $this->cron_helper);
     $scheduler->timer = microtime(true);
     $scheduler->process();
     $newQueue = ScheduledTask::findOne($queue->task_id);
diff --git a/tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php b/tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php
index e91cb2705f..b894960e98 100644
--- a/tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php
+++ b/tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php
@@ -7,11 +7,13 @@ use Codeception\Stub;
 use Codeception\Stub\Expected;
 use Codeception\Util\Fixtures;
 use MailPoet\Config\Populator;
+use MailPoet\Cron\CronHelper;
 use MailPoet\Cron\Workers\SendingQueue\SendingErrorHandler;
 use MailPoet\Cron\Workers\SendingQueue\SendingQueue as SendingQueueWorker;
 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\DI\ContainerWrapper;
 use MailPoet\Entities\NewsletterEntity;
 use MailPoet\Features\FeaturesController;
 use MailPoet\Logging\LoggerFactory;
@@ -100,11 +102,13 @@ class SendingQueueTest extends \MailPoetTest {
     $this->sending_error_handler = new SendingErrorHandler();
     $this->stats_notifications_worker = Stub::makeEmpty(StatsNotificationsScheduler::class);
     $this->logger_factory = LoggerFactory::getInstance();
+    $this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
     $this->sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
       $this->logger_factory,
-      Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()])
+      Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper
     );
   }
 
@@ -141,6 +145,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper,
       $timer
     );
     expect($sending_queue_worker->timer)->equals($timer);
@@ -152,7 +157,8 @@ class SendingQueueTest extends \MailPoetTest {
         $this->sending_error_handler,
         $this->stats_notifications_worker,
         $this->logger_factory,
-        Stub::makeEmpty(NewslettersRepository::class)
+        Stub::makeEmpty(NewslettersRepository::class),
+        $this->cron_helper
       ),
       [
         'processQueue' => Expected::never(),
@@ -160,7 +166,7 @@ class SendingQueueTest extends \MailPoetTest {
           throw new \Exception();
         }),
       ], $this);
-    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class));
+    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class), $this->cron_helper);
     try {
       $sending_queue_worker->process();
       self::fail('Execution limits function was not called.');
@@ -171,7 +177,7 @@ class SendingQueueTest extends \MailPoetTest {
 
   function testItEnforcesExecutionLimitsAfterSendingWhenQueueStatusIsNotSetToComplete() {
     $sending_queue_worker = Stub::make(
-      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class)),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class), $this->cron_helper),
       [
         'enforceSendingAndExecutionLimits' => Expected::exactly(1),
       ], $this);
@@ -180,6 +186,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -208,7 +215,7 @@ 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, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class)),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class), $this->cron_helper),
       [
         'enforceSendingAndExecutionLimits' => Expected::never(),
       ], $this);
@@ -217,6 +224,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -240,7 +248,7 @@ class SendingQueueTest extends \MailPoetTest {
 
   function testItEnforcesExecutionLimitsAfterQueueProcessing() {
     $sending_queue_worker = Stub::make(
-      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class)),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class), $this->cron_helper),
       [
         'processQueue' => function() {
           // this function returns a queue object
@@ -248,7 +256,7 @@ class SendingQueueTest extends \MailPoetTest {
         },
         'enforceSendingAndExecutionLimits' => Expected::exactly(2),
       ], $this);
-    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class));
+    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, Stub::makeEmpty(NewslettersRepository::class), $this->cron_helper);
     $sending_queue_worker->process();
   }
 
@@ -275,6 +283,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -305,6 +314,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -333,6 +343,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -380,6 +391,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -430,6 +442,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -487,6 +500,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper,
       $timer = false,
       Stub::makeEmpty(new MailerTask(), [], $this)
     );
@@ -505,6 +519,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -557,6 +572,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -723,13 +739,15 @@ class SendingQueueTest extends \MailPoetTest {
       $this->sending_error_handler,
       $this->stats_notifications_worker,
       $this->logger_factory,
-      Stub::makeEmpty(NewslettersRepository::class)
+      Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper
     ));
     $sending_queue_worker->__construct(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -766,6 +784,7 @@ class SendingQueueTest extends \MailPoetTest {
       $this->stats_notifications_worker,
       $this->logger_factory,
       Stub::makeEmpty(NewslettersRepository::class, ['findOneById' => new NewsletterEntity()]),
+      $this->cron_helper,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -794,7 +813,8 @@ class SendingQueueTest extends \MailPoetTest {
       $this->sending_error_handler,
       $this->stats_notifications_worker,
       $this->logger_factory,
-      Stub::makeEmpty(NewslettersRepository::class)
+      Stub::makeEmpty(NewslettersRepository::class),
+      $this->cron_helper
     );
     expect($sending_queue_worker->batch_size)->equals($custom_batch_size_value);
     $wp->removeFilter('mailpoet_cron_worker_sending_queue_batch_size', $filter);
diff --git a/tests/integration/Cron/Workers/SimpleWorkerTest.php b/tests/integration/Cron/Workers/SimpleWorkerTest.php
index f7108540a4..cd9aa9df16 100644
--- a/tests/integration/Cron/Workers/SimpleWorkerTest.php
+++ b/tests/integration/Cron/Workers/SimpleWorkerTest.php
@@ -7,6 +7,7 @@ use Codeception\Stub;
 use Codeception\Stub\Expected;
 use MailPoet\Cron\CronHelper;
 use MailPoet\Cron\Workers\SimpleWorkerMockImplementation as MockSimpleWorker;
+use MailPoet\DI\ContainerWrapper;
 use MailPoet\Models\ScheduledTask;
 use MailPoet\Models\Setting;
 
@@ -15,6 +16,7 @@ require_once('SimpleWorkerMockImplementation.php');
 class SimpleWorkerTest extends \MailPoetTest {
   function _before() {
     parent::_before();
+    $this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
     $this->worker = new MockSimpleWorker();
   }
 
@@ -40,7 +42,7 @@ class SimpleWorkerTest extends \MailPoetTest {
   function testItThrowsExceptionWhenExecutionLimitIsReached() {
     try {
       new MockSimpleWorker(
-        microtime(true) - CronHelper::getDaemonExecutionLimit()
+        microtime(true) - $this->cron_helper->getDaemonExecutionLimit()
       );
       self::fail('Maximum execution time limit exception was not thrown.');
     } catch (\Exception $e) {
@@ -213,7 +215,7 @@ class SimpleWorkerTest extends \MailPoetTest {
       [],
       [
         'processTaskStrategy' => function () {
-          CronHelper::enforceExecutionLimit(microtime(true) - CronHelper::DAEMON_EXECUTION_LIMIT - 1);
+          $this->cron_helper->enforceExecutionLimit(microtime(true) - CronHelper::DAEMON_EXECUTION_LIMIT - 1);
         },
       ],
       $this
diff --git a/tests/integration/Cron/Workers/StatsNotifications/WorkerTest.php b/tests/integration/Cron/Workers/StatsNotifications/WorkerTest.php
index 8f5d841898..eebb5858d0 100644
--- a/tests/integration/Cron/Workers/StatsNotifications/WorkerTest.php
+++ b/tests/integration/Cron/Workers/StatsNotifications/WorkerTest.php
@@ -3,6 +3,7 @@
 namespace MailPoet\Cron\Workers\StatsNotifications;
 
 use MailPoet\Config\Renderer;
+use MailPoet\Cron\CronHelper;
 use MailPoet\DI\ContainerWrapper;
 use MailPoet\Entities\StatsNotificationEntity;
 use MailPoet\Mailer\Mailer;
@@ -16,7 +17,6 @@ use MailPoet\Models\StatisticsOpens;
 use MailPoet\Models\StatisticsUnsubscribes;
 use MailPoet\Newsletter\Statistics\NewsletterStatisticsRepository;
 use MailPoet\Settings\SettingsController;
-use MailPoet\WooCommerce\Helper as WCHelper;
 use PHPUnit\Framework\MockObject\MockObject;
 
 class WorkerTest extends \MailPoetTest {
@@ -33,6 +33,9 @@ class WorkerTest extends \MailPoetTest {
   /** @var SettingsController */
   private $settings;
 
+  /** @var CronHelper */
+  private $cron_helper;
+
   /** @var Newsletter */
   private $newsletter;
 
@@ -57,10 +60,12 @@ class WorkerTest extends \MailPoetTest {
     $this->mailer = $this->createMock(Mailer::class);
     $this->renderer = $this->createMock(Renderer::class);
     $this->settings = new SettingsController();
+    $this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
     $this->stats_notifications = new Worker(
       $this->mailer,
       $this->renderer,
       $this->settings,
+      $this->cron_helper,
       new MetaInfo,
       $this->repository,
       $this->newsletter_link_repository,