- Adds unit tests for cron's sending queue worker and associated tasks

tests/unit/Cron/Workers/SendingQueue/SendingQueueTest.php

@@ -0,0 +1,316 @@
+<?php
+
+use Codeception\Util\Stub;
+use MailPoet\API\Endpoints\Cron;
+use MailPoet\Config\Populator;
+use MailPoet\Cron\CronHelper;
+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\Models\Newsletter;
+use MailPoet\Models\NewsletterLink;
+use MailPoet\Models\NewsletterPost;
+use MailPoet\Models\SendingQueue;
+use MailPoet\Models\StatisticsNewsletters;
+use MailPoet\Models\Subscriber;
+
+class SendingQueueTest extends MailPoetTest {
+  function _before() {
+    $wp_users = get_users();
+    wp_set_current_user($wp_users[0]->ID);
+    $populator = new Populator();
+    $populator->up();
+    $this->subscriber = Subscriber::create();
+    $this->subscriber->email = 'john@doe.com';
+    $this->subscriber->first_name = 'John';
+    $this->subscriber->last_name = 'Doe';
+    $this->subscriber->save();
+    $this->newsletter = Newsletter::create();
+    $this->newsletter->type = Newsletter::TYPE_STANDARD;
+    $this->newsletter->subject = 'Newsletter for [subscriber:firstname]';
+    $this->newsletter->body = '
+      {
+        "content": {
+          "type": "container",
+          "orientation": "vertical",
+          "blocks": [
+            {
+              "type": "container",
+              "styles": { "block": {} },
+              "orientation": "horizontal",
+              "blocks": [
+                {
+                  "type": "container",
+                  "orientation": "vertical",
+                  "styles": { "block": {} },
+                  "blocks": [
+                    {
+                      "type": "text",
+                      "text": "Sample newsletter"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      }';
+    $this->newsletter->save();
+    $this->queue = SendingQueue::create();
+    $this->queue->newsletter_id = $this->newsletter->id;
+    $this->queue->subscribers = serialize(
+      array(
+        'to_process' => array($this->subscriber->id),
+        'processed' => array(),
+        'failed' => array()
+      )
+    );
+    $this->queue->count_total = 1;
+    $this->queue->save();
+    $this->sending_queue_worker = new SendingQueueWorker();
+  }
+
+  function testItConstructs() {
+    expect($this->sending_queue_worker->mailer_task instanceof MailerTask);
+    expect($this->sending_queue_worker->newsletter_task instanceof NewsletterTask);
+    expect(strlen($this->sending_queue_worker->timer))->greaterOrEquals(5);
+
+    // constructor accepts timer argument
+    $timer = microtime(true) - 5;
+    $sending_queue_worker = new SendingQueueWorker($timer);
+    expect($sending_queue_worker->timer)->equals($timer);
+  }
+
+  function testItEnforcesExecutionLimitBeforeStart() {
+    $timer = microtime(true) - CronHelper::DAEMON_EXECUTION_LIMIT;
+    try {
+      $sending_queue_worker = new SendingQueueWorker($timer);
+      self::fail('Maximum execution time limit exception was not thrown.');
+    } catch(\Exception $e) {
+      expect($e->getMessage())->equals('Maximum execution time has been reached.');
+    }
+  }
+
+  function testItEnforcesExecutionLimitDuringProcessing() {
+    try {
+      $sending_queue_worker = $this->sending_queue_worker;
+      $sending_queue_worker->timer = microtime(true) - CronHelper::DAEMON_EXECUTION_LIMIT;
+      $sending_queue_worker->process();
+      self::fail('Maximum execution time limit exception was not thrown.');
+    } catch(\Exception $e) {
+      expect($e->getMessage())->equals('Maximum execution time has been reached.');
+    }
+  }
+
+  function testItDeletesQueueWhenNewsletterIsNotFound() {
+    // queue exists
+    $queue = SendingQueue::findOne($this->queue->id);
+    expect($queue)->notEquals(false);
+
+    // delete newsletter
+    Newsletter::findOne($this->newsletter->id)
+      ->delete();
+
+    // queue no longer exists
+    $this->sending_queue_worker->process();
+    $queue = SendingQueue::findOne($this->queue->id);
+    expect($queue)->false(false);
+  }
+
+  function testItCanProcessSubscribersOneByOne() {
+    $sending_queue_worker = $this->sending_queue_worker;
+    $sending_queue_worker->mailer_task = Stub::make(
+      new MailerTask(),
+      array('send' => Stub::exactly(1, function($newsletter, $subscriber) { return true; }))
+    );
+    $sending_queue_worker->process();
+
+    // newsletter status is set to sent
+    $updated_newsletter = Newsletter::findOne($this->newsletter->id);
+    expect($updated_newsletter->status)->equals(Newsletter::STATUS_SENT);
+
+    // queue status is set to completed
+    $updated_queue = SendingQueue::findOne($this->queue->id);
+    expect($updated_queue->status)->equals(SendingQueue::STATUS_COMPLETED);
+
+    // queue subscriber processed/failed/to process count is updated
+    $updated_queue->subscribers = $updated_queue->getSubscribers();
+    expect($updated_queue->subscribers)->equals(
+      array(
+        'to_process' => array(),
+        'failed' => array(),
+        'processed' => array($this->subscriber->id)
+      )
+    );
+    expect($updated_queue->count_total)->equals(1);
+    expect($updated_queue->count_processed)->equals(1);
+    expect($updated_queue->count_failed)->equals(0);
+    expect($updated_queue->count_to_process)->equals(0);
+
+    // statistics entry should be created
+    $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
+      ->where('subscriber_id', $this->subscriber->id)
+      ->where('queue_id', $this->queue->id)
+      ->findOne();
+    expect($statistics)->notEquals(false);
+  }
+
+  function testItCanProcessSubscribersInBulk() {
+    $sending_queue_worker = $this->sending_queue_worker;
+    $sending_queue_worker->mailer_task = Stub::make(
+      new MailerTask(),
+      array(
+        'send' => Stub::exactly(1, function($newsletter, $subscriber) { return true; }),
+        'getProcessingMethod' => Stub::exactly(1, function() { return 'bulk'; })
+      )
+    );
+    $sending_queue_worker->process();
+
+    // newsletter status is set to sent
+    $updated_newsletter = Newsletter::findOne($this->newsletter->id);
+    expect($updated_newsletter->status)->equals(Newsletter::STATUS_SENT);
+
+    // queue status is set to completed
+    $updated_queue = SendingQueue::findOne($this->queue->id);
+    expect($updated_queue->status)->equals(SendingQueue::STATUS_COMPLETED);
+
+    // queue subscriber processed/failed/to process count is updated
+    $updated_queue->subscribers = $updated_queue->getSubscribers();
+    expect($updated_queue->subscribers)->equals(
+      array(
+        'to_process' => array(),
+        'failed' => array(),
+        'processed' => array($this->subscriber->id)
+      )
+    );
+    expect($updated_queue->count_total)->equals(1);
+    expect($updated_queue->count_processed)->equals(1);
+    expect($updated_queue->count_failed)->equals(0);
+    expect($updated_queue->count_to_process)->equals(0);
+
+    // statistics entry should be created
+    $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
+      ->where('subscriber_id', $this->subscriber->id)
+      ->where('queue_id', $this->queue->id)
+      ->findOne();
+    expect($statistics)->notEquals(false);
+  }
+
+  function testItRemovesNonexistentSubscribersFromProcessingList() {
+    $queue = $this->queue;
+    $queue->subscribers = serialize(
+      array(
+        'to_process' => array(
+          $this->subscriber->id(),
+          123
+        ),
+        'processed' => array(),
+        'failed' => array()
+      )
+    );
+    $queue->count_total = 2;
+    $queue->save();
+    $sending_queue_worker = $this->sending_queue_worker;
+    $sending_queue_worker->mailer_task = Stub::make(
+      new MailerTask(),
+      array('send' => Stub::exactly(1, function($newsletter, $subscriber) { return true; }))
+    );
+    $sending_queue_worker->process();
+
+    $updated_queue = SendingQueue::findOne($queue->id);
+    // queue subscriber processed/failed/to process count is updated
+    $updated_queue->subscribers = $updated_queue->getSubscribers();
+    expect($updated_queue->subscribers)->equals(
+      array(
+        'to_process' => array(),
+        'failed' => array(),
+        'processed' => array($this->subscriber->id)
+      )
+    );
+    expect($updated_queue->count_total)->equals(1);
+    expect($updated_queue->count_processed)->equals(1);
+    expect($updated_queue->count_failed)->equals(0);
+    expect($updated_queue->count_to_process)->equals(0);
+
+    // statistics entry should be created only for 1 subscriber
+    $statistics = StatisticsNewsletters::findMany();
+    expect(count($statistics))->equals(1);
+  }
+
+  function testItUpdatesQueueSubscriberCountWhenNoneOfSubscribersExist() {
+    $queue = $this->queue;
+    $queue->subscribers = serialize(
+      array(
+        'to_process' => array(
+          123,
+          456
+        ),
+        'processed' => array(),
+        'failed' => array()
+      )
+    );
+    $queue->count_total = 2;
+    $queue->save();
+    $sending_queue_worker = $this->sending_queue_worker;
+    $sending_queue_worker->mailer_task = Stub::make(
+      new MailerTask(),
+      array('send' => Stub::exactly(1, function($newsletter, $subscriber) { return true; }))
+    );
+    $sending_queue_worker->process();
+
+    $updated_queue = SendingQueue::findOne($queue->id);
+    // queue subscriber processed/failed/to process count is updated
+    $updated_queue->subscribers = $updated_queue->getSubscribers();
+    expect($updated_queue->subscribers)->equals(
+      array(
+        'to_process' => array(),
+        'failed' => array(),
+        'processed' => array()
+      )
+    );
+    expect($updated_queue->count_total)->equals(0);
+    expect($updated_queue->count_processed)->equals(0);
+    expect($updated_queue->count_failed)->equals(0);
+    expect($updated_queue->count_to_process)->equals(0);
+  }
+
+  function testItUpdatesFailedListWhenSendingFailed() {
+    $sending_queue_worker = $this->sending_queue_worker;
+    $sending_queue_worker->mailer_task = Stub::make(
+      new MailerTask(),
+      array('send' => Stub::exactly(1, function($newsletter, $subscriber) { return false; }))
+    );
+    $sending_queue_worker->process();
+
+    // queue subscriber processed/failed/to process count is updated
+    $updated_queue = SendingQueue::findOne($this->queue->id);
+    $updated_queue->subscribers = $updated_queue->getSubscribers();
+    expect($updated_queue->subscribers)->equals(
+      array(
+        'to_process' => array(),
+        'failed' => array($this->subscriber->id),
+        'processed' => array()
+      )
+    );
+    expect($updated_queue->count_total)->equals(1);
+    expect($updated_queue->count_processed)->equals(1);
+    expect($updated_queue->count_failed)->equals(1);
+    expect($updated_queue->count_to_process)->equals(0);
+
+    // statistics entry should not be created
+    $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
+      ->where('subscriber_id', $this->subscriber->id)
+      ->where('queue_id', $this->queue->id)
+      ->findOne();
+    expect($statistics)->false();
+  }
+
+  function _after() {
+    ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
+    ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
+    ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
+    ORM::raw_execute('TRUNCATE ' . NewsletterLink::$_table);
+    ORM::raw_execute('TRUNCATE ' . NewsletterPost::$_table);
+    ORM::raw_execute('TRUNCATE ' . StatisticsNewsletters::$_table);
+  }
+}

tests/unit/Cron/Workers/SendingQueue/Tasks/LinksTest.php

@@ -0,0 +1,60 @@
+<?php
+use MailPoet\Cron\Workers\SendingQueue\Tasks\Links;
+use MailPoet\Models\Newsletter;
+use MailPoet\Models\NewsletterLink;
+
+if(!defined('ABSPATH')) exit;
+
+class LinkTaskTest extends MailPoetTest {
+  function testItCanSaveLinks() {
+    $links = array(
+      array(
+        'url' => 'http://example.com',
+        'hash' => 'some_hash'
+      )
+    );
+    $newsletter = (object)array('id' => 1);
+    $queue = (object)array('id' => 2);
+    $result = Links::saveLinks($links, $newsletter, $queue);
+    $newsletter_link = NewsletterLink::where('hash', $links[0]['hash'])
+      ->findOne();
+    expect($newsletter_link->newsletter_id)->equals($newsletter->id);
+    expect($newsletter_link->queue_id)->equals($queue->id);
+    expect($newsletter_link->url)->equals($links[0]['url']);
+  }
+
+  function testItCanHashAndReplaceLinks() {
+    $rendered_newsletter_body = array(
+      'html' => '<a href="http://example.com">Example Link</a>',
+      'text' => '<a href="http://example.com">Example Link</a>'
+    );
+    $result = Links::hashAndReplaceLinks($rendered_newsletter_body);
+    $processed_rendered_newsletter_body = $result[0];
+    $processed_and_hashed_links = $result[1];
+    expect($processed_rendered_newsletter_body['html'])
+      ->contains($processed_and_hashed_links[0]['hash']);
+    expect($processed_rendered_newsletter_body['text'])
+      ->contains($processed_and_hashed_links[0]['hash']);
+    expect($processed_and_hashed_links[0]['url'])->equals('http://example.com');
+  }
+
+  function testItCanProcessRenderedBody() {
+    $newsletter = Newsletter::create();
+    $newsletter->type = Newsletter::TYPE_STANDARD;
+    $newsletter->save();
+    $newsletter->_transient->rendered_body = array(
+      'html' => '<a href="http://example.com">Example Link</a>',
+      'text' => '<a href="http://example.com">Example Link</a>'
+    );
+    $queue = (object)array('id' => 2);
+    $result = Links::process($newsletter, $queue);
+    $newsletter_link = NewsletterLink::where('newsletter_id', $newsletter->id)
+      ->findOne();
+    expect($result->_transient->rendered_body['html'])->contains($newsletter_link->hash);
+  }
+
+  function _after() {
+    ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
+    ORM::raw_execute('TRUNCATE ' . NewsletterLink::$_table);
+  }
+}

tests/unit/Cron/Workers/SendingQueue/Tasks/MailerTest.php

@@ -0,0 +1,124 @@
+<?php
+use Codeception\Util\Stub;
+use MailPoet\Config\Populator;
+use MailPoet\Cron\Workers\SendingQueue\Tasks\Mailer as MailerTask;
+use MailPoet\Mailer\Mailer;
+use MailPoet\Mailer\Methods\PHPMail;
+use MailPoet\Models\Setting;
+use MailPoet\Models\Subscriber;
+
+if(!defined('ABSPATH')) exit;
+
+class MailerTaskTest extends MailPoetTest {
+  public $mailer_task;
+  public $sender;
+
+  function _before() {
+    $wp_users = get_users();
+    wp_set_current_user($wp_users[0]->ID);
+    $populator = new Populator();
+    $populator->up();
+    $this->mailer_task = new MailerTask();
+    $this->sender = Setting::getValue('sender');
+  }
+
+  function testConfiguresMailerWhenItConstructs() {
+    expect($this->mailer_task->mailer instanceof MailPoet\Mailer\Mailer)->true();
+  }
+
+  function testItCanConfigureMailerWithSenderAndReplyToAddresses() {
+    $newsletter = new stdClass();
+
+    // when no sender/reply-to information is set, use the sender information
+    // from Settings
+    $mailer = $this->mailer_task->configureMailer($newsletter);
+    expect($mailer->sender['from_name'])->equals($this->sender['name']);
+    expect($mailer->sender['from_email'])->equals($this->sender['address']);
+    expect($mailer->reply_to['reply_to_name'])->equals($this->sender['name']);
+    expect($mailer->reply_to['reply_to_email'])->equals($this->sender['address']);
+    $newsletter->sender_name = 'Sender';
+    $newsletter->sender_address = 'from@example.com';
+    $newsletter->reply_to_name = 'Reply-to';
+    $newsletter->reply_to_address = 'reply-to@example.com';
+
+    // when newsletter's sender/reply-to information is available, use that
+    // to configure mailer
+    $mailer = $this->mailer_task->configureMailer($newsletter);
+    expect($mailer->sender['from_name'])->equals($newsletter->sender_name);
+    expect($mailer->sender['from_email'])->equals($newsletter->sender_address);
+    expect($mailer->reply_to['reply_to_name'])->equals($newsletter->reply_to_name);
+    expect($mailer->reply_to['reply_to_email'])->equals($newsletter->reply_to_address);
+  }
+
+  function testItGetsMailerLog() {
+    $mailer_log = $this->mailer_task->getMailerLog();
+    expect(isset($mailer_log['sent']))->true();
+    expect(isset($mailer_log['started']))->true();
+  }
+
+  function testItUpdatesMailerLogSentCount() {
+    $mailer_log = $this->mailer_task->getMailerLog();
+    expect($mailer_log['sent'])->equals(0);
+    $mailer_log = $this->mailer_task->updateSentCount();
+    expect($mailer_log['sent'])->equals(1);
+  }
+
+  function testItGetsProcessingMethod() {
+    // when using MailPoet method, newsletters should be processed in bulk
+    Setting::setValue(
+      Mailer::MAILER_CONFIG_SETTING_NAME,
+      array(
+        'method' => 'MailPoet',
+        'mailpoet_api_key' => 'some_key',
+      )
+    );
+    $mailer_task = new MailerTask();
+    expect($mailer_task->getProcessingMethod())->equals('bulk');
+
+    // when using other methods, newsletters should be processed individually
+    Setting::setValue(
+      Mailer::MAILER_CONFIG_SETTING_NAME,
+      array(
+        'method' => 'PHPMail'
+      )
+    );
+    $mailer_task = new MailerTask();
+    expect($mailer_task->getProcessingMethod())->equals('individual');
+  }
+
+  function testItCanPrepareSubscriberForSending() {
+    $subscriber = Subscriber::create();
+    $subscriber->email = 'test@example.com';
+    $subscriber->first_name = 'John';
+    $subscriber->last_name = 'Doe';
+    $subscriber->save();
+    $prepared_subscriber = $this->mailer_task->prepareSubscriberForSending($subscriber);
+    expect($prepared_subscriber)->equals('John Doe <test@example.com>');
+  }
+
+  function testItCanSend() {
+    $php_mail_class = 'MailPoet\Mailer\Methods\PHPMail';
+    Setting::setValue(
+      Mailer::MAILER_CONFIG_SETTING_NAME,
+      array(
+        'method' => 'PHPMail'
+      )
+    );
+    $mailer_task = new MailerTask();
+    // mock mailer instance and ensure that send method is invoked
+    $mailer_task->mailer->mailer_instance = Stub::make(
+      $php_mail_class,
+      array('send' => Stub::exactly(1, function($newsletter, $subscriber) { return true; }))
+    );
+    // mailer instance should be properly configured
+    expect($mailer_task->mailer->mailer_instance instanceof $php_mail_class)
+      ->true();
+    // send method should return true
+    expect($mailer_task->send('Newsletter', 'Subscriber'))->true();
+  }
+
+  function _after() {
+    ORM::raw_execute('TRUNCATE ' . Setting::$_table);
+    ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
+  }
+}

tests/unit/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php

@@ -0,0 +1,171 @@
+<?php
+use MailPoet\Cron\Workers\SendingQueue\Tasks\Newsletter as NewsletterTask;
+use MailPoet\Models\Newsletter;
+use MailPoet\Models\NewsletterLink;
+use MailPoet\Models\NewsletterPost;
+use MailPoet\Models\SendingQueue;
+use MailPoet\Models\Subscriber;
+use MailPoet\Router\Router;
+
+if(!defined('ABSPATH')) exit;
+
+class NewsletterTaskTest extends MailPoetTest {
+  function _before() {
+    $this->newsletter_task = new NewsletterTask();
+    $this->subscriber = Subscriber::create();
+    $this->subscriber->email = 'test@example.com';
+    $this->subscriber->first_name = 'John';
+    $this->subscriber->last_name = 'Doe';
+    $this->subscriber->save();
+    $this->post_id = 10;
+    $this->newsletter = Newsletter::create();
+    $this->newsletter->type = Newsletter::TYPE_STANDARD;
+    $this->newsletter->subject = 'Newsletter for [subscriber:firstname]';
+    $this->newsletter->body = '
+      {
+        "content": {
+          "type": "container",
+          "orientation": "vertical",
+          "blocks": [
+            {
+              "type": "container",
+              "styles": { "block": {} },
+              "orientation": "horizontal",
+              "blocks": [
+                {
+                  "type": "container",
+                  "orientation": "vertical",
+                  "styles": { "block": {} },
+                  "blocks": [
+                    {
+                      "type": "text",
+                      "text": "<a data-post-id=\"' . $this->post_id . '\" href=\"http://example.com\">Link</a>Hello [subscriber:firstname]"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      }';
+    $this->newsletter->save();
+    $this->queue = SendingQueue::create();
+    $this->queue->newsletter_id = $this->newsletter->id;
+    $this->queue->save();
+  }
+
+  function testItConstructs() {
+    expect($this->newsletter_task->tracking_enabled)->true();
+  }
+
+  function testItFailsToGetAndProcessNewsletterWhenNewsletterDoesNotExist() {
+    $queue = $this->queue;
+    $queue->newsletter_id = 0;
+    expect($this->newsletter_task->getAndPreProcess($queue))->false();
+  }
+
+  function testItReturnsRenderedNewsletterBodyWhenItExists() {
+    $queue = $this->queue;
+    $queue->newsletter_rendered_body = json_encode('Sample newsletter');
+    $result = $this->newsletter_task->getAndPreProcess($queue);
+    expect($result->_transient->rendered_body)->equals(json_decode($queue->newsletter_rendered_body));
+  }
+
+  function testItHashesLinksAndInsertsTrackingImageWhenTrackingIsEnabled() {
+    $newsletter_task = $this->newsletter_task;
+    $newsletter_task->tracking_enabled = true;
+    $result = $newsletter_task->getAndPreProcess($this->queue);
+    $link = NewsletterLink::where('newsletter_id', $this->newsletter->id)
+      ->findOne();
+    expect($result->_transient->rendered_body['html'])
+      ->contains('[mailpoet_click_data]-' . $link->hash);
+    expect($result->_transient->rendered_body['html'])
+      ->contains('[mailpoet_open_data]');
+  }
+
+  function testItDoesNotHashLinksAndInsertTrackingCodeWhenTrackingIsDisabled() {
+    $newsletter_task = $this->newsletter_task;
+    $newsletter_task->tracking_enabled = false;
+    $result = $newsletter_task->getAndPreProcess($this->queue);
+    $link = NewsletterLink::where('newsletter_id', $this->newsletter->id)
+      ->findOne();
+    expect($link)->false();
+    expect($result->_transient->rendered_body['html'])
+      ->notContains('[mailpoet_click_data]');
+    expect($result->_transient->rendered_body['html'])
+      ->notContains('[mailpoet_open_data]');
+  }
+
+  function testReturnsFalseWhenNewsletterIsANotificationWithoutPosts() {
+    $newsletter = $this->newsletter;
+    $newsletter->type = Newsletter::TYPE_NOTIFICATION;
+    // replace post id data tag with something else
+    $newsletter->body = str_replace('data-post-id', 'id', $newsletter->body);
+    $newsletter->save();
+    $result = $this->newsletter_task->getAndPreProcess($this->queue);
+    expect($result)->false();
+  }
+
+  function testItSavesNewsletterPosts() {
+    $result = $this->newsletter_task->getAndPreProcess($this->queue);
+    $newsletter_post = NewsletterPost::where('newsletter_id', $this->newsletter->id)
+      ->findOne();
+    expect($result)->notEquals(false);
+    expect($newsletter_post->post_id)->equals($this->post_id);
+  }
+
+  function testItUpdatesStatusToSentOnlyForStandardNewsletters() {
+    // newsletter type is 'standard'
+    $newsletter = $this->newsletter;
+    expect($newsletter->type)->equals(Newsletter::TYPE_STANDARD);
+    expect($newsletter->status)->notEquals(Newsletter::STATUS_SENT);
+    $this->newsletter_task->markNewsletterAsSent($newsletter);
+    $updated_newsletter = Newsletter::findOne($newsletter->id);
+    expect($updated_newsletter->status)->equals(Newsletter::STATUS_SENT);
+
+    // newsletter type is NOT 'standard'
+    $newsletter->type = Newsletter::TYPE_NOTIFICATION;
+    $newsletter->status = 'not_sent';
+    $newsletter->save();
+    $this->newsletter_task->markNewsletterAsSent($newsletter);
+    $updated_newsletter = Newsletter::findOne($newsletter->id);
+    expect($updated_newsletter->status)->notEquals(Newsletter::STATUS_SENT);
+  }
+
+  function testItRendersShortcodesAndReplacesSubscriberDataInLinks() {
+    $newsletter = $this->newsletter_task->getAndPreProcess($this->queue);
+    $result = $this->newsletter_task->prepareNewsletterForSending(
+      $newsletter,
+      $this->subscriber,
+      $this->queue
+    );
+    expect($result['subject'])->contains($this->subscriber->first_name);
+    expect($result['body']['html'])
+      ->contains(Router::NAME . '&endpoint=track&action=click&data=');
+    expect($result['body']['text'])
+      ->contains(Router::NAME . '&endpoint=track&action=click&data=');
+  }
+
+  function testItDoesNotReplaceSubscriberDataInLinksWhenTrackingIsNotEnabled() {
+    $newsletter_task = $this->newsletter_task;
+    $newsletter_task->tracking_enabled = false;
+    $newsletter = $newsletter_task->getAndPreProcess($this->queue);
+    $result = $newsletter_task->prepareNewsletterForSending(
+      $newsletter,
+      $this->subscriber,
+      $this->queue
+    );
+    expect($result['body']['html'])
+      ->notContains(Router::NAME . '&endpoint=track&action=click&data=');
+    expect($result['body']['text'])
+      ->notContains(Router::NAME . '&endpoint=track&action=click&data=');
+  }
+
+  function _after() {
+    ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
+    ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
+    ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
+    ORM::raw_execute('TRUNCATE ' . NewsletterLink::$_table);
+    ORM::raw_execute('TRUNCATE ' . NewsletterPost::$_table);
+  }
+}

tests/unit/Cron/Workers/SendingQueue/Tasks/PostsTest.php

@@ -0,0 +1,64 @@
+<?php
+
+use MailPoet\Cron\Workers\SendingQueue\Tasks\Posts as PostsTask;
+use MailPoet\Models\Newsletter;
+use MailPoet\Models\NewsletterPost;
+
+if(!defined('ABSPATH')) exit;
+
+class PostsTaskTest extends MailPoetTest {
+  function testItFailsWhenNewsletterDoesNotExist() {
+    expect(PostsTask::extractAndSave($newsletter = false))->equals(false);
+  }
+
+  function testItFailsWhenNoPostsArePresent() {
+    $newsletter = (object)array(
+      'id' => 1,
+      '_transient' => (object)array(
+        'rendered_body' => array(
+          'html' => 'Sample newsletter'
+        )
+      )
+    );
+    expect(PostsTask::extractAndSave($newsletter))->equals(false);
+  }
+
+  function testItCanExtractAndSavePosts() {
+    $post_id = 10;
+    $newsletter = (object)array(
+      'id' => 1,
+      'type' => Newsletter::TYPE_STANDARD,
+      '_transient' => (object)array(
+        'rendered_body' => array(
+          'html' => '<a data-post-id="' . $post_id . '" href="#">sample post</a>'
+        )
+      )
+    );
+    expect(PostsTask::extractAndSave($newsletter))->equals(true);
+    $newsletter_post = NewsletterPost::where('newsletter_id', $newsletter->id)
+      ->findOne();
+    expect($newsletter_post->post_id)->equals($post_id);
+  }
+
+  function testItSetsNewsletterIdToParentIdWhenNewsletterIsANotificationHistory() {
+    $post_id = 10;
+    $newsletter = (object)array(
+      'id' => 2,
+      'parent_id' => 1,
+      'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
+      '_transient' => (object)array(
+        'rendered_body' => array(
+          'html' => '<a data-post-id="' . $post_id . '" href="#">sample post</a>'
+        )
+      )
+    );
+    expect(PostsTask::extractAndSave($newsletter))->equals(true);
+    $newsletter_post = NewsletterPost::where('newsletter_id', $newsletter->parent_id)
+      ->findOne();
+    expect($newsletter_post->post_id)->equals($post_id);
+  }
+
+  function _after() {
+    ORM::raw_execute('TRUNCATE ' . NewsletterPost::$_table);
+  }
+}

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

@@ -0,0 +1,28 @@
+<?php
+use MailPoet\Cron\Workers\SendingQueue\Tasks\Shortcodes;
+use MailPoet\Models\Newsletter;
+use MailPoet\Models\SendingQueue;
+
+if(!defined('ABSPATH')) exit;
+
+class ShortcodesTaskTest extends MailPoetTest {
+  function testItCanReplaceShortcodes() {
+    $queue = $newsletter = array(
+      'id' => 1
+
+    );
+    $subscriber = array(
+      'email' => 'test@xample. com',
+      'first_name' => 'John',
+      'last_name' => 'Doe'
+    );
+    $rendered_body = '[subscriber:firstname] [subscriber:lastname]';
+    $result = Shortcodes::process($rendered_body, $newsletter, $subscriber, $queue);
+    expect($result)->equals('John Doe');
+  }
+
+  function _after() {
+    ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
+    ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
+  }
+}

tests/unit/Cron/Workers/SendingQueue/Tasks/SubscribersTest.php

@@ -0,0 +1,96 @@
+<?php
+use MailPoet\Cron\Workers\SendingQueue\Tasks\Subscribers;
+
+if(!defined('ABSPATH')) exit;
+
+class SubscribersTaskTest extends MailPoetTest {
+  function testItCanSplitSubscribersInBatches() {
+    $subscribers = range(1, 200);
+    $split_subscribers = Subscribers::splitSubscribersIntoBatches($subscribers);
+    expect(count($split_subscribers))->equals(200 / Subscribers::BATCH_SIZE);
+    expect(count($split_subscribers[0]))->equals(Subscribers::BATCH_SIZE);
+  }
+
+  function testItCanRemoveNonexistentSubscribersFromListOfSubscribersToProcess() {
+    $queue_subscribers = array(
+      'to_process' => range(1, 5)
+    );
+    $subscribers_found = array(
+      1,
+      2,
+      5
+    );
+    $subscribers_to_process = array(
+      3,
+      4
+    );
+    $updated_queue_subscribers = Subscribers::updateToProcessList(
+      $subscribers_found,
+      $subscribers_to_process,
+      $queue_subscribers
+    );
+    expect($updated_queue_subscribers)->equals(
+      array(
+        'to_process' => array(
+          1,
+          2,
+          5
+        )
+      )
+    );
+  }
+
+  function testItCanUpdateListOfFailedSubscribers() {
+    $queue_subscribers = array(
+      'to_process' => range(1, 5),
+      'failed' => array()
+    );
+    $failed_subscribers = array(
+      1
+    );
+    $updated_queue_subscribers = Subscribers::updateFailedList(
+      $failed_subscribers,
+      $queue_subscribers
+    );
+    expect($updated_queue_subscribers)->equals(
+      array(
+        'to_process' => array(
+          2,
+          3,
+          4,
+          5
+        ),
+        'failed' => array(
+          1
+        )
+      )
+    );
+  }
+
+  function testItCanUpdateListOfProcessedSubscribers() {
+    $queue_subscribers = array(
+      'to_process' => range(1, 5),
+      'processed' => array()
+    );
+    $processed_subscribers = array(
+      1
+    );
+    $updated_queue_subscribers = Subscribers::updateProcessedList(
+      $processed_subscribers,
+      $queue_subscribers
+    );
+    expect($updated_queue_subscribers)->equals(
+      array(
+        'to_process' => array(
+          2,
+          3,
+          4,
+          5
+        ),
+        'processed' => array(
+          1
+        )
+      )
+    );
+  }
+}