Refactor shortcode categories to doctrine

[MAILPOET-2993]

lib/Cron/Workers/SendingQueue/Tasks/Shortcodes.php

@@ -27,19 +27,19 @@ class Shortcodes {
     /** @var SubscribersRepository $subscribersRepository */
     $subscribersRepository = ContainerWrapper::getInstance()->get(SubscribersRepository::class);
 
-    if ($queue instanceof Sending || $queue instanceof SendingQueue) {
+    if (($queue instanceof Sending || $queue instanceof SendingQueue) && $queue->id) {
       $queue = $sendingQueueRepository->findOneById($queue->id);
     }
     if ($queue instanceof SendingQueueEntity) {
       $shortcodes->setQueue($queue);
     }
-    if ($newsletter instanceof \MailPoet\Models\Newsletter) {
+    if ($newsletter instanceof \MailPoet\Models\Newsletter && $newsletter->id) {
       $newsletter = $newsletterRepository->findOneById($newsletter->id);
     }
     if ($newsletter instanceof NewsletterEntity) {
       $shortcodes->setNewsletter($newsletter);
     }
-    if ($subscriber instanceof Subscriber) {
+    if ($subscriber instanceof Subscriber && $subscriber->id) {
       $subscriber = $subscribersRepository->findOneById($subscriber->id);
     }
     if ($subscriber instanceof SubscriberEntity) {

lib/DI/ContainerConfigurator.php

@@ -309,6 +309,10 @@ class ContainerConfigurator implements IContainerConfigurator {
     $container->autowire(\MailPoet\Newsletter\Segment\NewsletterSegmentRepository::class)->setPublic(true);
     $container->autowire(\MailPoet\Newsletter\Shortcodes\ShortcodesHelper::class)->setPublic(true);
     $container->autowire(\MailPoet\Newsletter\Shortcodes\Shortcodes::class)->setPublic(true);
+    $container->autowire(\MailPoet\Newsletter\Shortcodes\Categories\Date::class)->setPublic(true);
+    $container->autowire(\MailPoet\Newsletter\Shortcodes\Categories\Link::class)->setPublic(true);
+    $container->autowire(\MailPoet\Newsletter\Shortcodes\Categories\Newsletter::class)->setPublic(true);
+    $container->autowire(\MailPoet\Newsletter\Shortcodes\Categories\Subscriber::class)->setPublic(true);
     $container->autowire(\MailPoet\Newsletter\Statistics\NewsletterStatisticsRepository::class)->setPublic(true);
     $container->autowire(\MailPoet\Newsletter\Scheduler\WelcomeScheduler::class)->setPublic(true);
     $container->autowire(\MailPoet\Newsletter\Scheduler\PostNotificationScheduler::class)->setPublic(true);

lib/Doctrine/Repository.php

@@ -37,6 +37,10 @@ abstract class Repository {
     return $this->doctrineRepository->findBy($criteria, $orderBy, $limit, $offset);
   }
 
+  public function countBy(array $criteria): int {
+    return $this->doctrineRepository->count($criteria);
+  }
+
   /**
    * @param array $criteria
    * @param array|null $orderBy

lib/Newsletter/Shortcodes/Categories/CategoryInterface.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace MailPoet\Newsletter\Shortcodes\Categories;
+
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Entities\SubscriberEntity;
+
+interface CategoryInterface {
+  public function process(
+    array $shortcodeDetails,
+    NewsletterEntity $newsletter = null,
+    SubscriberEntity $subscriber = null,
+    SendingQueueEntity $queue = null,
+    string $content = '',
+    bool $wpUserPreview = false
+  ): ?string;
+}

lib/Newsletter/Shortcodes/Categories/Date.php

@@ -2,12 +2,20 @@
 
 namespace MailPoet\Newsletter\Shortcodes\Categories;
 
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Entities\SubscriberEntity;
 use MailPoet\WP\Functions as WPFunctions;
 
-class Date {
+class Date implements CategoryInterface {
-  public static function process(
+  public function process(
-    $shortcodeDetails
+    array $shortcodeDetails,
-  ) {
+    NewsletterEntity $newsletter = null,
+    SubscriberEntity $subscriber = null,
+    SendingQueueEntity $queue = null,
+    string $content = '',
+    bool $wpUserPreview = false
+  ): ?string {
     $actionMapping = [
       'd' => 'd',
       'dordinal' => 'jS',
@@ -22,6 +30,6 @@ class Date {
     }
     return ($shortcodeDetails['action'] === 'custom' && $shortcodeDetails['action_argument'] === 'format') ?
       WPFunctions::get()->dateI18n($shortcodeDetails['action_argument_value'], $wp->currentTime('timestamp')) :
-      false;
+      null;
   }
 }

lib/Newsletter/Shortcodes/Categories/Link.php

@@ -2,31 +2,52 @@
 
 namespace MailPoet\Newsletter\Shortcodes\Categories;
 
+use MailPoet\Entities\NewsletterEntity;
 use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Entities\SubscriberEntity;
+use MailPoet\Models\Newsletter as NewsletterModel;
+use MailPoet\Models\SendingQueue;
+use MailPoet\Models\Subscriber as SubscriberModel;
 use MailPoet\Newsletter\Url as NewsletterUrl;
 use MailPoet\Settings\SettingsController;
 use MailPoet\Subscription\SubscriptionUrlFactory;
-use MailPoet\Tasks\Sending;
 use MailPoet\WP\Functions as WPFunctions;
 
-class Link {
+class Link implements CategoryInterface {
   const CATEGORY_NAME = 'link';
 
-  public static function process(
+  /** @var SettingsController */
-    $shortcodeDetails,
+  private $settings;
-    $newsletter,
+
-    $subscriber,
+  /** @var WPFunctions */
-    $queue,
+  private $wp;
-    $content,
+
-    $wpUserPreview
+  public function __construct(
+    SettingsController $settings,
+    WPFunctions $wp
   ) {
+    $this->settings = $settings;
+    $this->wp = $wp;
+  }
+
+  public function process(
+    array $shortcodeDetails,
+    NewsletterEntity $newsletter = null,
+    SubscriberEntity $subscriber = null,
+    SendingQueueEntity $queue = null,
+    string $content = '',
+    bool $wpUserPreview = false
+  ): ?string {
     $subscriptionUrlFactory = SubscriptionUrlFactory::getInstance();
+    $subscriberModel = $this->getSubscriberModel($subscriber);
+    $newsletterModel = $this->getNewsletterModel($newsletter);
+    $queueModel = $this->getQueueModel($queue);
 
     switch ($shortcodeDetails['action']) {
       case 'subscription_unsubscribe_url':
         return self::processUrl(
           $shortcodeDetails['action'],
-          $subscriptionUrlFactory->getConfirmUnsubscribeUrl($wpUserPreview ? null : $subscriber, self::getSendingQueueId($queue)),
+          $subscriptionUrlFactory->getConfirmUnsubscribeUrl($wpUserPreview ? null : $subscriberModel, self::getSendingQueueId($queue)),
           $queue,
           $wpUserPreview
         );
@@ -34,7 +55,7 @@ class Link {
       case 'subscription_instant_unsubscribe_url':
         return self::processUrl(
           $shortcodeDetails['action'],
-          $subscriptionUrlFactory->getUnsubscribeUrl($wpUserPreview ? null : $subscriber, self::getSendingQueueId($queue)),
+          $subscriptionUrlFactory->getUnsubscribeUrl($wpUserPreview ? null : $subscriberModel, self::getSendingQueueId($queue)),
           $queue,
           $wpUserPreview
         );
@@ -42,96 +63,121 @@ class Link {
       case 'subscription_manage_url':
         return self::processUrl(
           $shortcodeDetails['action'],
-          $subscriptionUrlFactory->getManageUrl($wpUserPreview ? null : $subscriber),
+          $subscriptionUrlFactory->getManageUrl($wpUserPreview ? null : $subscriberModel),
           $queue,
           $wpUserPreview
         );
 
       case 'newsletter_view_in_browser_url':
         $url = NewsletterUrl::getViewInBrowserUrl(
-          $newsletter,
+          $newsletterModel,
           $wpUserPreview ? null : $subscriber,
-          $queue,
+          $queueModel,
           $wpUserPreview
         );
         return self::processUrl($shortcodeDetails['action'], $url, $queue, $wpUserPreview);
 
       default:
         $shortcode = self::getFullShortcode($shortcodeDetails['action']);
-        $url = WPFunctions::get()->applyFilters(
+        $url = $this->wp->applyFilters(
           'mailpoet_newsletter_shortcode_link',
           $shortcode,
-          $newsletter,
+          $newsletterModel,
-          $subscriber,
+          $subscriberModel,
-          $queue,
+          $queueModel,
           $wpUserPreview
         );
+
         return ($url !== $shortcode) ?
           self::processUrl($shortcodeDetails['action'], $url, $queue, $wpUserPreview) :
-          false;
+          null;
     }
   }
 
-  public static function processUrl($action, $url, $queue, $wpUserPreview = false) {
+  public function processUrl($action, $url, $queue, $wpUserPreview = false): string {
     if ($wpUserPreview) return $url;
-    $settings = SettingsController::getInstance();
+    return ($queue !== false && (boolean)$this->settings->get('tracking.enabled')) ?
-    return ($queue !== false && (boolean)$settings->get('tracking.enabled')) ?
       self::getFullShortcode($action) :
       $url;
   }
 
-  public static function processShortcodeAction(
+  public function processShortcodeAction(
-    $shortcodeAction, $newsletter, $subscriber, $queue, $wpUserPreview
+    $shortcodeAction,
-  ) {
+    NewsletterEntity $newsletter = null,
+    SubscriberEntity $subscriber = null,
+    SendingQueueEntity $queue = null,
+    $wpUserPreview = false
+  ): ?string {
+    $subscriberModel = $this->getSubscriberModel($subscriber);
+    $newsletterModel = $this->getNewsletterModel($newsletter);
+    $queueModel = $this->getQueueModel($queue);
     $subscriptionUrlFactory = SubscriptionUrlFactory::getInstance();
     switch ($shortcodeAction) {
       case 'subscription_unsubscribe_url':
-        $url = $subscriptionUrlFactory->getConfirmUnsubscribeUrl($subscriber, self::getSendingQueueId($queue));
+        $url = $subscriptionUrlFactory->getConfirmUnsubscribeUrl($subscriberModel, self::getSendingQueueId($queue));
         break;
       case 'subscription_instant_unsubscribe_url':
-        $url = $subscriptionUrlFactory->getUnsubscribeUrl($subscriber, self::getSendingQueueId($queue));
+        $url = $subscriptionUrlFactory->getUnsubscribeUrl($subscriberModel, self::getSendingQueueId($queue));
         break;
       case 'subscription_manage_url':
-        $url = $subscriptionUrlFactory->getManageUrl($subscriber);
+        $url = $subscriptionUrlFactory->getManageUrl($subscriberModel);
         break;
       case 'newsletter_view_in_browser_url':
         $url = NewsletterUrl::getViewInBrowserUrl(
-          $newsletter,
+          $newsletterModel,
-          $subscriber,
+          $subscriberModel,
-          $queue,
+          $queueModel,
           false
         );
         break;
       default:
         $shortcode = self::getFullShortcode($shortcodeAction);
-        $url = WPFunctions::get()->applyFilters(
+        $url = $this->wp->applyFilters(
           'mailpoet_newsletter_shortcode_link',
           $shortcode,
-          $newsletter,
+          $newsletterModel,
-          $subscriber,
+          $subscriberModel,
-          $queue,
+          $queueModel,
           $wpUserPreview
         );
-        $url = ($url !== $shortcodeAction) ? $url : false;
+        $url = ($url !== $shortcodeAction) ? $url : null;
         break;
     }
     return $url;
   }
 
-  private static function getFullShortcode($action) {
+  private function getFullShortcode($action): string {
     return sprintf('[link:%s]', $action);
   }
 
-  /**
+  private function getSendingQueueId($queue): ?int {
-   * @return int|null
-   */
-  private static function getSendingQueueId($queue) {
-    if ($queue instanceof Sending) {
-      return (int)$queue->id;
-    }
     if ($queue instanceof SendingQueueEntity) {
       return $queue->getId();
     }
     return null;
   }
+
+  // temporary function until Links are refactored to Doctrine
+  private function getSubscriberModel(SubscriberEntity $subscriber = null): ?SubscriberModel {
+    if (!$subscriber) return null;
+    $subscriberModel = SubscriberModel::where('id', $subscriber->getId())->findOne();
+    if ($subscriberModel) return $subscriberModel;
+    return null;
+  }
+
+  // temporary function until Links are refactored to Doctrine
+  private function getNewsletterModel(NewsletterEntity $newsletter = null): ?NewsletterModel {
+    if (!$newsletter) return null;
+    $newsletterModel = NewsletterModel::where('id', $newsletter->getId())->findOne();
+    if ($newsletterModel) return $newsletterModel;
+    return null;
+  }
+
+  // temporary function until Links are refactored to Doctrine
+  private function getQueueModel(SendingQueueEntity $queue = null): ?SendingQueue {
+    if (!$queue) return null;
+    $queueModel = SendingQueue::where('id', $queue->getId())->findOne();
+    if ($queueModel) return $queueModel;
+    return null;
+  }
 }

lib/Newsletter/Shortcodes/Categories/Newsletter.php

@@ -2,45 +2,59 @@
 
 namespace MailPoet\Newsletter\Shortcodes\Categories;
 
-use MailPoet\Models\Newsletter as NewsletterModel;
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Entities\SubscriberEntity;
+use MailPoet\Newsletter\NewslettersRepository;
 use MailPoet\WP\Functions as WPFunctions;
 use MailPoet\WP\Posts as WPPosts;
 
-class Newsletter {
+class Newsletter implements CategoryInterface {
-  public static function process(
+  /** @var NewslettersRepository */
-    $shortcodeDetails,
+  private $newslettersRepository;
-    $newsletter,
+
-    $subscriber,
+  public function __construct(NewslettersRepository $newslettersRepository) {
-    $queue,
+    $this->newslettersRepository = $newslettersRepository;
-    $content
+  }
-  ) {
+
+  public function process(
+    array $shortcodeDetails,
+    NewsletterEntity $newsletter = null,
+    SubscriberEntity $subscriber = null,
+    SendingQueueEntity $queue = null,
+    string $content = '',
+    bool $wpUserPreview = false
+  ): ?string {
     switch ($shortcodeDetails['action']) {
       case 'subject':
-        return ($newsletter) ? $newsletter->subject : false;
+        return ($newsletter instanceof NewsletterEntity) ? $newsletter->getSubject() : null;
 
       case 'total':
-        return substr_count($content, 'data-post-id');
+        return (string)substr_count($content, 'data-post-id');
 
       case 'post_title':
         preg_match_all('/data-post-id="(\d+)"/ism', $content, $posts);
         $postIds = array_unique($posts[1]);
-        $latestPost = (!empty($postIds)) ? self::getLatestWPPost($postIds) : false;
+        $latestPost = (!empty($postIds)) ? $this->getLatestWPPost($postIds) : null;
-        return ($latestPost) ? $latestPost['post_title'] : false;
+        return ($latestPost) ? $latestPost['post_title'] : null;
 
       case 'number':
-        if ($newsletter->type !== NewsletterModel::TYPE_NOTIFICATION_HISTORY) return false;
+        if (!($newsletter instanceof NewsletterEntity)) return null;
-        $sentNewsletters =
+        if ($newsletter->getType() !== NewsletterEntity::TYPE_NOTIFICATION_HISTORY) {
-          NewsletterModel::where('parent_id', $newsletter->parentId)
+          return null;
-            ->where('status', NewsletterModel::STATUS_SENT)
+        }
-            ->count();
+        $sentNewsletters = $this->newslettersRepository->countBy([
-        return ++$sentNewsletters;
+          'parent' => $newsletter->getParent(),
+          'status' => NewsletterEntity::STATUS_SENT,
+        ]);
+        return (string)++$sentNewsletters;
 
       default:
-        return false;
+        return null;
     }
   }
 
-  public static function ensureConsistentQueryType(\WP_Query $query) {
+  public function ensureConsistentQueryType(\WP_Query $query) {
     // Queries with taxonomies are autodetected as 'is_archive=true' and 'is_home=false'
     // while queries without them end up being 'is_archive=false' and 'is_home=true'.
     // This is to fix that by always enforcing constistent behavior.
@@ -48,10 +62,10 @@ class Newsletter {
     $query->is_home = false; // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
   }
 
-  private static function getLatestWPPost($postIds) {
+  private function getLatestWPPost($postIds) {
     // set low priority to execute 'ensureConstistentQueryType' before any other filter
     $filterPriority = defined('PHP_INT_MIN') ? constant('PHP_INT_MIN') : ~PHP_INT_MAX;
-    WPFunctions::get()->addAction('pre_get_posts', [get_called_class(), 'ensureConsistentQueryType'], $filterPriority);
+    WPFunctions::get()->addAction('pre_get_posts', [$this, 'ensureConsistentQueryType'], $filterPriority);
     $posts = new \WP_Query(
       [
         'post_type' => WPPosts::getTypes(),
@@ -62,7 +76,7 @@ class Newsletter {
         'order' => 'DESC',
       ]
     );
-    WPFunctions::get()->removeAction('pre_get_posts', [get_called_class(), 'ensureConsistentQueryType'], $filterPriority);
+    WPFunctions::get()->removeAction('pre_get_posts', [$this, 'ensureConsistentQueryType'], $filterPriority);
     return (!empty($posts->posts[0])) ?
       $posts->posts[0]->to_array() :
       false;

lib/Newsletter/Shortcodes/Categories/Subscriber.php

@@ -2,52 +2,67 @@
 
 namespace MailPoet\Newsletter\Shortcodes\Categories;
 
-use MailPoet\Models\Subscriber as SubscriberModel;
+use MailPoet\Entities\NewsletterEntity;
-use MailPoet\Models\SubscriberCustomField;
+use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Entities\SubscriberCustomFieldEntity;
+use MailPoet\Entities\SubscriberEntity;
+use MailPoet\Subscribers\SubscriberCustomFieldRepository;
+use MailPoet\Subscribers\SubscribersRepository;
 use MailPoet\WP\Functions as WPFunctions;
 
-class Subscriber {
+class Subscriber implements CategoryInterface {
-  /**
+
-   * @param \MailPoet\Models\Subscriber|false|mixed $subscriber
+  /** @var SubscribersRepository */
-   */
+  private $subscribersRepository;
-  public static function process(
+
-    $shortcodeDetails,
+  /** @var SubscriberCustomFieldRepository */
-    $newsletter,
+  private $subscriberCustomFieldRepository;
-    $subscriber
+
+  public function __construct(
+    SubscribersRepository $subscribersRepository,
+    SubscriberCustomFieldRepository $subscriberCustomFieldRepository
   ) {
-    if ($subscriber !== false && !($subscriber instanceof SubscriberModel)) {
+    $this->subscribersRepository = $subscribersRepository;
-      return $shortcodeDetails['shortcode'];
+    $this->subscriberCustomFieldRepository = $subscriberCustomFieldRepository;
-    }
+  }
+
+  public function process(
+    array $shortcodeDetails,
+    NewsletterEntity $newsletter = null,
+    SubscriberEntity $subscriber = null,
+    SendingQueueEntity $queue = null,
+    string $content = '',
+    bool $wpUserPreview = false
+  ): ?string {
     $defaultValue = ($shortcodeDetails['action_argument'] === 'default') ?
       $shortcodeDetails['action_argument_value'] :
       '';
     switch ($shortcodeDetails['action']) {
       case 'firstname':
-        return (!empty($subscriber->firstName)) ? $subscriber->firstName : $defaultValue;
+        return (($subscriber instanceof SubscriberEntity) && !empty($subscriber->getFirstName())) ? $subscriber->getFirstName() : $defaultValue;
       case 'lastname':
-        return (!empty($subscriber->lastName)) ? $subscriber->lastName : $defaultValue;
+        return (($subscriber instanceof SubscriberEntity) && !empty($subscriber->getLastName())) ? $subscriber->getLastName() : $defaultValue;
       case 'email':
-        return ($subscriber) ? $subscriber->email : false;
+        return ($subscriber instanceof SubscriberEntity) ? $subscriber->getEmail() : $defaultValue;
       case 'displayname':
-        if ($subscriber && $subscriber->wpUserId) {
+        if (($subscriber instanceof SubscriberEntity) && $subscriber->getWpUserId()) {
-          $wpUser = WPFunctions::get()->getUserdata($subscriber->wpUserId);
+          $wpUser = WPFunctions::get()->getUserdata($subscriber->getWpUserId());
           return $wpUser->user_login; // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
         }
         return $defaultValue;
       case 'count':
-        return SubscriberModel::filter('subscribed')
+        return (string)$this->subscribersRepository->getTotalSubscribers();
-          ->count();
       default:
         if (preg_match('/cf_(\d+)/', $shortcodeDetails['action'], $customField) &&
-          !empty($subscriber->id)
+          !empty($subscriber->getId())
         ) {
-          $customField = SubscriberCustomField
+          $customField = $this->subscriberCustomFieldRepository->findOneBy([
-            ::where('subscriber_id', $subscriber->id)
+            'subscriber' => $subscriber,
-            ->where('custom_field_id', $customField[1])
+            'customField' => $customField[1],
-            ->findOne();
+          ]);
-          return ($customField instanceof SubscriberCustomField) ? $customField->value : false;
+          return ($customField instanceof SubscriberCustomFieldEntity) ? $customField->getValue() : null;
         }
-        return false;
+        return null;
     }
   }
 }

lib/Newsletter/Shortcodes/Shortcodes.php

@@ -5,6 +5,11 @@ namespace MailPoet\Newsletter\Shortcodes;
 use MailPoet\Entities\NewsletterEntity;
 use MailPoet\Entities\SendingQueueEntity;
 use MailPoet\Entities\SubscriberEntity;
+use MailPoet\Newsletter\Shortcodes\Categories\CategoryInterface;
+use MailPoet\Newsletter\Shortcodes\Categories\Date;
+use MailPoet\Newsletter\Shortcodes\Categories\Link;
+use MailPoet\Newsletter\Shortcodes\Categories\Newsletter;
+use MailPoet\Newsletter\Shortcodes\Categories\Subscriber;
 use MailPoet\WP\Functions as WPFunctions;
 
 class Shortcodes {
@@ -22,6 +27,30 @@ class Shortcodes {
   /** @var bool */
   private $wpUserPreview = false;
 
+  /** @var Date */
+  private $dateCategory;
+
+  /** @var Link */
+  private $linkCategory;
+
+  /** @var Newsletter */
+  private $newsletterCategory;
+
+  /** @var Subscriber */
+  private $subscriberCategory;
+
+  public function __construct(
+    Date $dateCategory,
+    Link $linkCategory,
+    Newsletter $newsletterCategory,
+    Subscriber $subscriberCategory
+  ) {
+    $this->dateCategory = $dateCategory;
+    $this->linkCategory = $linkCategory;
+    $this->newsletterCategory = $newsletterCategory;
+    $this->subscriberCategory = $subscriberCategory;
+  }
+
   public function setNewsletter(NewsletterEntity $newsletter): void {
     $this->newsletter = $newsletter;
   }
@@ -65,26 +94,36 @@ class Shortcodes {
     return $match;
   }
 
-  public function process($shortcodes, $content = false) {
+  public function process($shortcodes, $content = '') {
     $processedShortcodes = [];
     foreach ($shortcodes as $shortcode) {
       $shortcodeDetails = $this->match($shortcode);
       $shortcodeDetails['shortcode'] = $shortcode;
       $shortcodeDetails['category'] = !empty($shortcodeDetails['category']) ?
         $shortcodeDetails['category'] :
-        false;
+        '';
       $shortcodeDetails['action'] = !empty($shortcodeDetails['action']) ?
         $shortcodeDetails['action'] :
-        false;
+        '';
       $shortcodeDetails['action_argument'] = !empty($shortcodeDetails['argument']) ?
         $shortcodeDetails['argument'] :
-        false;
+        '';
       $shortcodeDetails['action_argument_value'] = !empty($shortcodeDetails['argument_value']) ?
         $shortcodeDetails['argument_value'] :
         false;
-      $shortcodeClass =
+
-        Shortcodes::SHORTCODE_CATEGORY_NAMESPACE . ucfirst($shortcodeDetails['category']);
+      $category = strtolower($shortcodeDetails['category']);
-      if (!class_exists($shortcodeClass)) {
+      $categoryClass = $this->getCategoryObject($category);
+      if ($categoryClass instanceof CategoryInterface) {
+        $processedShortcodes[] = $categoryClass->process(
+          $shortcodeDetails,
+          $this->newsletter,
+          $this->subscriber,
+          $this->queue,
+          $content,
+          $this->wpUserPreview
+        );
+      } else {
         $customShortcode = WPFunctions::get()->applyFilters(
           'mailpoet_newsletter_shortcode',
           $shortcode,
@@ -98,14 +137,7 @@ class Shortcodes {
           false :
           $customShortcode;
       }
-      $processedShortcodes[] = $shortcodeClass::process(
+
-        $shortcodeDetails,
-        $this->newsletter,
-        $this->subscriber,
-        $this->queue,
-        $content,
-        $this->wpUserPreview
-      );
     }
     return $processedShortcodes;
   }
@@ -125,4 +157,17 @@ class Shortcodes {
     $shortcodes = array_intersect_key($shortcodes, $processedShortcodes);
     return str_replace($shortcodes, $processedShortcodes, $content);
   }
+
+  private function getCategoryObject($category): ?CategoryInterface {
+    if ($category === 'link') {
+      return $this->linkCategory;
+    } elseif ($category === 'date') {
+      return $this->dateCategory;
+    } elseif ($category === 'newsletter') {
+      return $this->newsletterCategory;
+    } elseif ($category === 'subscriber') {
+      return $this->subscriberCategory;
+    }
+    return null;
+  }
 }

lib/Router/Endpoints/Track.php

@@ -4,6 +4,7 @@ namespace MailPoet\Router\Endpoints;
 
 use MailPoet\Config\AccessControl;
 use MailPoet\Cron\Workers\StatsNotifications\NewsletterLinkRepository;
+use MailPoet\Entities\SendingQueueEntity;
 use MailPoet\Models\SendingQueue;
 use MailPoet\Models\Subscriber;
 use MailPoet\Newsletter\Links\Links;
@@ -84,7 +85,10 @@ class Track {
     }
     $data->queue = $this->sendingQueuesRepository->findOneById($data->queue_id);// phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
     $data->subscriber = $this->subscribersRepository->findOneById($data->subscriber_id); // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
-    $data->newsletter = $this->newslettersRepository->findOneById($data->newsletter_id); // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
+    $data->newsletter = (isset($data->newsletter_id)) ? $this->newslettersRepository->findOneById($data->newsletter_id) : null; // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
+    if (!$data->newsletter && ($data->queue instanceof SendingQueueEntity)) {
+      $data->newsletter = $data->queue->getNewsletter();
+    }
     if (!empty($data->link_hash)) { // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
       $data->link = $this->newsletterLinkRepository->findOneBy([
         'hash' => $data->link_hash, // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
@@ -108,6 +112,7 @@ class Track {
     // check if the newsletter was sent to the subscriber
     $queue = SendingQueue::findOne($data->queue_id); // phpcs:ignore Squiz.NamingConventions.ValidVariableName.NotCamelCaps
     if (!$queue instanceof SendingQueue) return false;
+
     return ($queue->isSubscriberProcessed($data->subscriber->getId())) ?
       $data :
       false;

lib/Statistics/Track/Clicks.php

@@ -7,7 +7,7 @@ use MailPoet\Entities\NewsletterLinkEntity;
 use MailPoet\Entities\SendingQueueEntity;
 use MailPoet\Entities\SubscriberEntity;
 use MailPoet\Models\StatisticsClicks;
-use MailPoet\Newsletter\Shortcodes\Categories\Link;
+use MailPoet\Newsletter\Shortcodes\Categories\Link as LinkShortcodeCategory;
 use MailPoet\Newsletter\Shortcodes\Shortcodes;
 use MailPoet\Settings\SettingsController;
 use MailPoet\Util\Cookies;
@@ -30,14 +30,19 @@ class Clicks {
   /** @var Shortcodes */
   private $shortcodes;
 
+  /** @var LinkShortcodeCategory */
+  private $linkShortcodeCategory;
+
   public function __construct(
     SettingsController $settingsController,
     Cookies $cookies,
-    Shortcodes $shortcodes
+    Shortcodes $shortcodes,
+    LinkShortcodeCategory $linkShortcodeCategory
   ) {
     $this->settingsController = $settingsController;
     $this->cookies = $cookies;
     $this->shortcodes = $shortcodes;
+    $this->linkShortcodeCategory = $linkShortcodeCategory;
   }
 
   /**
@@ -96,7 +101,7 @@ class Clicks {
       $this->cookies->set(
         self::ABANDONED_CART_COOKIE_NAME,
         [
-          'subscriber_id' => $subscriber->id,
+          'subscriber_id' => $subscriber->getId(),
         ],
         [
           'expires' => time() + self::ABANDONED_CART_COOKIE_EXPIRY,
@@ -115,7 +120,7 @@ class Clicks {
   ) {
     if (preg_match('/\[link:(?P<action>.*?)\]/', $url, $shortcode)) {
       if (!$shortcode['action']) $this->abort();
-      $url = Link::processShortcodeAction(
+      $url = $this->linkShortcodeCategory->processShortcodeAction(
         $shortcode['action'],
         $newsletter,
         $subscriber,

tests/integration/Cron/Workers/SendingQueue/Tasks/ShortcodesTest.php

@@ -26,9 +26,8 @@ class ShortcodesTest extends \MailPoetTest {
     $queue = $newsletter = (object)[
       'id' => 1,
     ];
-    $subscriber = Subscriber::create();
+    $subscriber = Subscriber::createOrUpdate([
-    $subscriber->hydrate([
+      'email' => 'test@xample.com',
-      'email' => 'test@xample. com',
       'first_name' => 'John',
       'last_name' => 'Doe',
     ]);

tests/integration/Newsletter/Preview/SendPreviewControllerTest.php

@@ -5,6 +5,7 @@ namespace MailPoet\Newsletter\Preview;
 use Codeception\Stub\Expected;
 use Codeception\Util\Fixtures;
 use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\SubscriberEntity;
 use MailPoet\Mailer\Mailer;
 use MailPoet\Mailer\MailerError;
 use MailPoet\Mailer\MetaInfo;
@@ -25,6 +26,8 @@ class SendPreviewControllerTest extends \MailPoetTest {
 
   public function _before() {
     parent::_before();
+    $this->truncateEntity(NewsletterEntity::class);
+    $this->truncateEntity(SubscriberEntity::class);
     $this->subscriptionUrlFactory = SubscriptionUrlFactory::getInstance();
     $newsletter = new NewsletterEntity();
     $newsletter->setType(NewsletterEntity::TYPE_STANDARD);
@@ -33,10 +36,25 @@ class SendPreviewControllerTest extends \MailPoetTest {
     $newsletter->setBody(json_decode(Fixtures::get('newsletter_body_template'), true));
     $newsletter->setHash(Security::generateHash());
     $this->entityManager->persist($newsletter);
+
+    $subscriber = new SubscriberEntity();
+    $subscriber->setEmail('test@subscriber.com');
+    $subscriber->setWpUserId(5);
+    $this->entityManager->persist($subscriber);
     $this->entityManager->flush();
+
+    $wpUser = new \stdClass();
+    $wpUser->ID = 5;
+    $wp = $this->make(WPFunctions::class, ['wpGetCurrentUser' => $wpUser]);
+    WPFunctions::set($wp);
+    
     $this->newsletter = $newsletter;
   }
 
+  public function _after() {
+    WPFunctions::set(new WPFunctions());
+  }
+
   public function testItCanSendAPreview() {
     $mailer = $this->makeEmpty(Mailer::class, [
       'send' => Expected::once(
@@ -71,8 +89,8 @@ class SendPreviewControllerTest extends \MailPoetTest {
       new MetaInfo(),
       $this->diContainer->get(Renderer::class),
       new WPFunctions(),
-      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(SubscribersRepository::class),
-      $this->diContainer->get(SubscribersRepository::class)
+      $this->diContainer->get(Shortcodes::class)
     );
     $sendPreviewController->sendPreview($this->newsletter, 'test@subscriber.com');
   }
@@ -100,8 +118,8 @@ class SendPreviewControllerTest extends \MailPoetTest {
       new MetaInfo(),
       $this->diContainer->get(Renderer::class),
       new WPFunctions(),
-      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(SubscribersRepository::class),
-      $this->diContainer->get(SubscribersRepository::class)
+      $this->diContainer->get(Shortcodes::class)
     );
     $sendPreviewController->sendPreview($this->newsletter, 'test@subscriber.com');
   }

tests/integration/Newsletter/ShortcodesTest.php

@@ -9,6 +9,7 @@ use MailPoet\Entities\SendingQueueEntity;
 use MailPoet\Entities\SubscriberCustomFieldEntity;
 use MailPoet\Entities\SubscriberEntity;
 use MailPoet\Models\Newsletter;
+use MailPoet\Models\Newsletter as NewsletterModel;
 use MailPoet\Models\Subscriber;
 use MailPoet\Newsletter\Shortcodes\Categories\Date;
 use MailPoet\Newsletter\Shortcodes\Shortcodes;
@@ -36,18 +37,22 @@ class ShortcodesTest extends \MailPoetTest {
 
   public function _before() {
     parent::_before();
+    $this->cleanup();
     $this->settings = SettingsController::getInstance();
     $populator = $this->diContainer->get(Populator::class);
     $populator->up();
     $this->wPUser = $this->_createWPUser();
     $this->wPPost = $this->_createWPPost();
     $this->subscriber = $this->_createSubscriber();
+    $this->entityManager->persist($this->subscriber);
     $this->newsletter = $this->_createNewsletter();
+    $this->entityManager->persist($this->newsletter);
     $this->shortcodesObject = $this->diContainer->get(Shortcodes::class);
     $this->shortcodesObject->setNewsletter($this->newsletter);
     $this->shortcodesObject->setSubscriber($this->subscriber);
     $this->settings->set('tracking.enabled', false);
     $this->subscriptionUrlFactory = new SubscriptionUrlFactory(WPFunctions::get(), $this->settings, new LinkTokens);
+    $this->entityManager->flush();
   }
 
   public function testItCanExtractShortcodes() {
@@ -98,21 +103,22 @@ class ShortcodesTest extends \MailPoetTest {
   }
 
   public function testItCanProcessDateShortcodes() {
+    $date = $this->diContainer->get(Date::class);
     $shortcodeDetails = ['action' => 'd'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('d', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('d', WPFunctions::get()->currentTime('timestamp')));
     $shortcodeDetails = ['action' => 'dordinal'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('jS', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('jS', WPFunctions::get()->currentTime('timestamp')));
     $shortcodeDetails = ['action' => 'dtext'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('l', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('l', WPFunctions::get()->currentTime('timestamp')));
     $shortcodeDetails = ['action' => 'm'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('m', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('m', WPFunctions::get()->currentTime('timestamp')));
     $shortcodeDetails = ['action' => 'mtext'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('F', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('F', WPFunctions::get()->currentTime('timestamp')));
     $shortcodeDetails = ['action' => 'y'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('Y', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('Y', WPFunctions::get()->currentTime('timestamp')));
     // allow custom date formats (http://php.net/manual/en/function.date.php)
     $shortcodeDetails = ['action' => 'custom', 'action_argument' => 'format', 'action_argument_value' => 'U F'];
-    expect(Date::process($shortcodeDetails))->equals(date_i18n('U F', WPFunctions::get()->currentTime('timestamp')));
+    expect($date->process($shortcodeDetails))->equals(date_i18n('U F', WPFunctions::get()->currentTime('timestamp')));
   }
 
   public function testItCanProcessNewsletterShortcodes() {
@@ -186,20 +192,16 @@ class ShortcodesTest extends \MailPoetTest {
     $result =
       $shortcodesObject->process(['[subscriber:displayname]']);
     expect($result[0])->equals($this->wPUser->user_login);
-    $subscribers = Subscriber::where('status', 'subscribed')
+    $subscribers = Subscriber::whereIn('status', [
-      ->findMany();
+      SubscriberEntity::STATUS_SUBSCRIBED,
+      SubscriberEntity::STATUS_UNCONFIRMED,
+      SubscriberEntity::STATUS_INACTIVE,
+    ])->findMany();
     $subscriberCount = count($subscribers);
     $result =
       $shortcodesObject->process(['[subscriber:count]']);
     expect($result[0])->equals($subscriberCount);
     $this->subscriber->setStatus('unsubscribed');
-    $result =
-      $shortcodesObject->process(['[subscriber:count]']);
-    expect($result[0])->equals($subscriberCount - 1);
-    $this->subscriber->setStatus('bounced');
-    $result =
-      $shortcodesObject->process(['[subscriber:count]']);
-    expect($result[0])->equals($subscriberCount - 1);
   }
 
   public function testItCanProcessSubscriberCustomFieldShortcodes() {
@@ -213,7 +215,7 @@ class ShortcodesTest extends \MailPoetTest {
     $result = $shortcodesObject->process(
       ['[subscriber:cf_' . $customField->getId() . ']']
     );
-    expect($result[0])->false();
+    expect($result[0])->null();
     $subscriberCustomField = new SubscriberCustomFieldEntity($subscriber, $customField, 'custom_field_value');
     $this->entityManager->persist($subscriberCustomField);
     $this->entityManager->flush();
@@ -242,6 +244,7 @@ class ShortcodesTest extends \MailPoetTest {
 
   public function testItReturnsShortcodeWhenTrackingEnabled() {
     $shortcodesObject = $this->shortcodesObject;
+    $shortcodesObject->setWpUserPreview(false);
     // Returns URL when tracking is not enabled
     $shortcode = '[link:subscription_unsubscribe_url]';
     $result =
@@ -278,6 +281,8 @@ class ShortcodesTest extends \MailPoetTest {
   public function testItReturnsDefaultLinksWhenPreviewIsEnabled() {
     $shortcodesObject = $this->shortcodesObject;
     $shortcodesObject->setWpUserPreview(true);
+    $shortcodesObject->setSubscriber(null);
+    $newsletterModel = NewsletterModel::where('id', $this->newsletter->getId())->findOne();
     $shortcodes = [
       '[link:subscription_unsubscribe_url]',
       '[link:subscription_instant_unsubscribe_url]',
@@ -288,7 +293,7 @@ class ShortcodesTest extends \MailPoetTest {
       $this->subscriptionUrlFactory->getConfirmUnsubscribeUrl(null),
       $this->subscriptionUrlFactory->getUnsubscribeUrl(null),
       $this->subscriptionUrlFactory->getManageUrl(null),
-      NewsletterUrl::getViewInBrowserUrl($this->newsletter),
+      NewsletterUrl::getViewInBrowserUrl($newsletterModel),
     ];
     $result = $shortcodesObject->process($shortcodes);
     // hash is returned
@@ -299,19 +304,21 @@ class ShortcodesTest extends \MailPoetTest {
 
   public function testItCanProcessCustomLinkShortcodes() {
     $shortcodesObject = $this->shortcodesObject;
+    $shortcodesObject->setWpUserPreview(false);
     $shortcode = '[link:shortcode]';
     $result = $shortcodesObject->process([$shortcode]);
-    expect($result[0])->false();
+    expect($result[0])->null();
-    add_filter('mailpoet_newsletter_shortcode_link', function(
+    remove_all_filters('mailpoet_newsletter_shortcode_link');
-      $shortcode, $newsletter, $subscriber, $queue) {
+    add_filter('mailpoet_newsletter_shortcode_link', function($shortcode, $newsletter, $subscriber, $queue) {
       if ($shortcode === '[link:shortcode]') return 'success';
     }, 10, 4);
+
     $result = $shortcodesObject->process([$shortcode]);
     expect($result[0])->equals('success');
     $this->settings->set('tracking.enabled', true);
     // tracking function only works during sending, so queue object must not be false
     $shortcodesObject->setQueue($this->_createQueue());
-    $result = $shortcodesObject->process([$shortcode]);
+    $result = $shortcodesObject->process([$shortcode], 'x');
     expect($result[0])->equals($shortcode);
   }
 
@@ -359,12 +366,16 @@ class ShortcodesTest extends \MailPoetTest {
   }
 
   public function _after() {
+    $this->cleanup();
+  }
+
+  public function cleanup() {
     $this->truncateEntity(NewsletterEntity::class);
     $this->truncateEntity(SubscriberEntity::class);
     $this->truncateEntity(SendingQueueEntity::class);
     $this->truncateEntity(CustomFieldEntity::class);
     $this->truncateEntity(SubscriberCustomFieldEntity::class);
-    wp_delete_post($this->wPPost, true);
+    if ($this->wPPost) wp_delete_post($this->wPPost, true);
-    wp_delete_user($this->wPUser->ID);
+    if ($this->wPUser) wp_delete_user($this->wPUser->ID);
   }
 }

tests/integration/Router/Endpoints/TrackTest.php

@@ -27,6 +27,7 @@ class TrackTest extends \MailPoetTest {
 
   public function _before() {
     parent::_before();
+    $this->cleanup();
     // create newsletter
     $newsletter = new NewsletterEntity();
     $newsletter->setType('type');
@@ -48,12 +49,15 @@ class TrackTest extends \MailPoetTest {
     $queue = new SendingQueueEntity();
     $queue->setTask($task);
     $queue->setNewsletter($newsletter);
+    $queue->setSubscribers((string)$subscriber->getId());
     $this->queue = $queue;
     $this->entityManager->persist($queue);
     // create link
     $link = new NewsletterLinkEntity($newsletter, $queue, 'url', 'hash');
     $this->link = $link;
     $this->entityManager->persist($link);
+    $scheduledTaskSubscriber = new ScheduledTaskSubscriberEntity($task, $subscriber, 1);
+    $this->entityManager->persist($scheduledTaskSubscriber);
     $this->entityManager->flush();
     $subscriberModel = Subscriber::findOne($subscriber->getId());
     $linkTokens = new LinkTokens;
@@ -162,10 +166,10 @@ class TrackTest extends \MailPoetTest {
 
   public function testItProcessesTrackData() {
     $processedData = $this->track->_processTrackData($this->trackData);
-    expect($processedData->queue->id)->equals($this->queue->id);
+    expect($processedData->queue->getId())->equals($this->queue->getId());
-    expect($processedData->subscriber->id)->equals($this->subscriber->id);
+    expect($processedData->subscriber->getId())->equals($this->subscriber->getId());
-    expect($processedData->newsletter->id)->equals($this->newsletter->id);
+    expect($processedData->newsletter->getId())->equals($this->newsletter->getId());
-    expect($processedData->link->id)->equals($this->link->id);
+    expect($processedData->link->getId())->equals($this->link->getId());
   }
 
   public function testItGetsProperHashWhenDuplicateHashesExist() {
@@ -175,16 +179,16 @@ class TrackTest extends \MailPoetTest {
     $newsletter = $newsletter->save();
     $queue = SendingTask::create();
     $queue->newsletterId = $newsletter->id;
-    $queue->setSubscribers([$this->subscriber->id]);
+    $queue->setSubscribers([$this->subscriber->getId()]);
-    $queue->updateProcessedSubscribers([$this->subscriber->id]);
+    $queue->updateProcessedSubscribers([$this->subscriber->getId()]);
     $queue->save();
     $trackData = $this->trackData;
     $trackData['queue_id'] = $queue->id;
     $trackData['newsletter_id'] = $newsletter->id;
     // create another link with the same hash but different queue ID
     $link = NewsletterLink::create();
-    $link->hash = $this->link->hash;
+    $link->hash = $this->link->getHash();
-    $link->url = $this->link->url;
+    $link->url = $this->link->getUrl();
     $link->newsletterId = $trackData['newsletter_id'];
     $link->queueId = $trackData['queue_id'];
     $link = $link->save();
@@ -194,10 +198,14 @@ class TrackTest extends \MailPoetTest {
 
     // assert that the fetched link ID belong to the newly created link
     $processedData = $this->track->_processTrackData($trackData);
-    expect($processedData->link->id)->equals($link->id);
+    expect($processedData->link->getId())->equals($link->id);
   }
 
   public function _after() {
+    $this->cleanup();
+  }
+
+  private function cleanup() {
     $this->truncateEntity(NewsletterEntity::class);
     $this->truncateEntity(SubscriberEntity::class);
     $this->truncateEntity(NewsletterLinkEntity::class);

tests/integration/Statistics/Track/ClicksTest.php

@@ -15,6 +15,7 @@ use MailPoet\Models\SendingQueue;
 use MailPoet\Models\StatisticsClicks;
 use MailPoet\Models\StatisticsOpens;
 use MailPoet\Models\Subscriber;
+use MailPoet\Newsletter\Shortcodes\Categories\Link as LinkShortcodeCategory;
 use MailPoet\Newsletter\Shortcodes\Shortcodes;
 use MailPoet\Settings\SettingsController;
 use MailPoet\Statistics\Track\Clicks;
@@ -84,12 +85,22 @@ class ClicksTest extends \MailPoetTest {
     $this->settingsController = Stub::makeEmpty(SettingsController::class, [
       'get' => false,
     ], $this);
-    $this->clicks = new Clicks($this->settingsController, new Cookies(), $this->diContainer->get(Shortcodes::class));
+    $this->clicks = new Clicks(
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class)
+    );
   }
 
   public function testItAbortsWhenTrackDataIsEmptyOrMissingLink() {
     // abort function should be called twice:
-    $clicks = Stub::construct($this->clicks, [$this->settingsController, new Cookies()], [
+    $clicks = Stub::construct($this->clicks, [
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class),
+    ], [
       'abort' => Expected::exactly(2),
     ], $this);
     $data = $this->trackData;
@@ -105,7 +116,12 @@ class ClicksTest extends \MailPoetTest {
     $this->subscriber->setWpUserId(99);
     $this->entityManager->flush();
     $data->preview = true;
-    $clicks = Stub::construct($this->clicks, [$this->settingsController, new Cookies()], [
+    $clicks = Stub::construct($this->clicks, [
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class),
+    ], [
       'redirectToUrl' => null,
     ], $this);
     $clicks->track($data);
@@ -115,7 +131,12 @@ class ClicksTest extends \MailPoetTest {
 
   public function testItTracksClickAndOpenEvent() {
     $data = $this->trackData;
-    $clicks = Stub::construct($this->clicks, [$this->settingsController, new Cookies()], [
+    $clicks = Stub::construct($this->clicks, [
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class),
+    ], [
       'redirectToUrl' => null,
     ], $this);
     $clicks->track($data);
@@ -124,14 +145,24 @@ class ClicksTest extends \MailPoetTest {
   }
 
   public function testItRedirectsToUrlAfterTracking() {
-    $clicks = Stub::construct($this->clicks, [$this->settingsController, new Cookies()], [
+    $clicks = Stub::construct($this->clicks, [
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class),
+    ], [
       'redirectToUrl' => Expected::exactly(1),
     ], $this);
     $clicks->track($this->trackData);
   }
 
   public function testItIncrementsClickEventCount() {
-    $clicks = Stub::construct($this->clicks, [$this->settingsController, new Cookies()], [
+    $clicks = Stub::construct($this->clicks, [
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class),
+    ], [
       'redirectToUrl' => null,
     ], $this);
     $clicks->track($this->trackData);
@@ -152,7 +183,12 @@ class ClicksTest extends \MailPoetTest {
   }
 
   public function testItFailsToConvertsInvalidShortcodeToUrl() {
-    $clicks = Stub::construct($this->clicks, [$this->settingsController, new Cookies()], [
+    $clicks = Stub::construct($this->clicks, [
+      $this->settingsController,
+      new Cookies(),
+      $this->diContainer->get(Shortcodes::class),
+      $this->diContainer->get(LinkShortcodeCategory::class),
+    ], [
       'abort' => Expected::exactly(1),
     ], $this);
     // should call abort() method if shortcode action does not exist

tests/integration/Statistics/Track/OpensTest.php

@@ -4,11 +4,16 @@ namespace MailPoet\Test\Statistics\Track;
 
 use Codeception\Stub;
 use Codeception\Stub\Expected;
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\ScheduledTaskEntity;
+use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Entities\SubscriberEntity;
 use MailPoet\Models\Newsletter;
 use MailPoet\Models\ScheduledTask;
 use MailPoet\Models\SendingQueue;
 use MailPoet\Models\StatisticsOpens;
 use MailPoet\Models\Subscriber;
+use MailPoet\Models\Subscriber as SubscriberModel;
 use MailPoet\Statistics\Track\Opens;
 use MailPoet\Subscribers\LinkTokens;
 use MailPoet\Tasks\Sending as SendingTask;
@@ -23,29 +28,43 @@ class OpensTest extends \MailPoetTest {
 
   public function _before() {
     parent::_before();
+    $this->cleanup();
     // create newsletter
-    $newsletter = Newsletter::create();
+    $newsletter = new NewsletterEntity();
-    $newsletter->type = 'type';
+    $newsletter->setType('type');
-    $this->newsletter = $newsletter->save();
+    $newsletter->setSubject('subject');
+    $this->entityManager->persist($newsletter);
+    $this->newsletter = $newsletter;
     // create subscriber
-    $subscriber = Subscriber::create();
+    $subscriber = new SubscriberEntity();
-    $subscriber->email = 'test@example.com';
+    $subscriber->setEmail('test@example.com');
-    $subscriber->firstName = 'First';
+    $subscriber->setFirstName('First');
-    $subscriber->lastName = 'Last';
+    $subscriber->setLastName('Last');
-    $this->subscriber = $subscriber->save();
+    $subscriber->setLinkToken('token');
+    $this->subscriber = $subscriber;
+    $this->entityManager->persist($subscriber);
     // create queue
-    $queue = SendingTask::create();
+    $task = new ScheduledTaskEntity();
-    $queue->newsletterId = $newsletter->id;
+    $task->setType(SendingTask::TASK_TYPE);
-    $queue->setSubscribers([$subscriber->id]);
+    $task->setStatus(ScheduledTaskEntity::STATUS_COMPLETED);
-    $queue->updateProcessedSubscribers([$subscriber->id]);
+    $this->entityManager->persist($task);
-    $this->queue = $queue->save();
+
+    $queue = new SendingQueueEntity();
+    $queue->setNewsletter($newsletter);
+    $queue->setTask($task);
+    $queue->setSubscribers((string)$subscriber->getId());
+    $newsletter->getQueues()->add($queue);
+    $this->entityManager->persist($queue);
+    $this->entityManager->flush();
+
+    $this->queue = $queue;
     $linkTokens = new LinkTokens;
     // build track data
     $this->trackData = (object)[
       'queue' => $queue,
       'subscriber' => $subscriber,
       'newsletter' => $newsletter,
-      'subscriber_token' => $linkTokens->getToken($subscriber),
+      'subscriber_token' => $linkTokens->getToken(SubscriberModel::findOne('test@example.com')),
       'preview' => false,
     ];
     // instantiate class
@@ -62,7 +81,7 @@ class OpensTest extends \MailPoetTest {
 
   public function testItDoesNotTrackOpenEventFromWpUserWhenPreviewIsEnabled() {
     $data = $this->trackData;
-    $data->subscriber->wp_user_id = 99;
+    $data->subscriber->setWpUserId(99);
     $data->preview = true;
     $opens = Stub::make($this->opens, [
       'returnResponse' => null,
@@ -101,6 +120,10 @@ class OpensTest extends \MailPoetTest {
   }
 
   public function _after() {
+    $this->cleanup();
+  }
+
+  public function cleanup() {
     ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
     ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
     ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);