From e11fd66fec5b3307edd014aa1ecbbfab2bb90998 Mon Sep 17 00:00:00 2001 From: Vlad Date: Sun, 18 Sep 2016 23:16:19 -0400 Subject: [PATCH] - Adds unit tests for cron's sending queue worker and associated tasks --- .../Workers/SendingQueue/SendingQueueTest.php | 316 ++++++++++++++++++ .../Workers/SendingQueue/Tasks/LinksTest.php | 60 ++++ .../Workers/SendingQueue/Tasks/MailerTest.php | 124 +++++++ .../SendingQueue/Tasks/NewsletterTest.php | 171 ++++++++++ .../Workers/SendingQueue/Tasks/PostsTest.php | 64 ++++ .../SendingQueue/Tasks/ShortcodesTest.php | 28 ++ .../SendingQueue/Tasks/SubscribersTest.php | 96 ++++++ 7 files changed, 859 insertions(+) create mode 100644 tests/unit/Cron/Workers/SendingQueue/SendingQueueTest.php create mode 100644 tests/unit/Cron/Workers/SendingQueue/Tasks/LinksTest.php create mode 100644 tests/unit/Cron/Workers/SendingQueue/Tasks/MailerTest.php create mode 100644 tests/unit/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php create mode 100644 tests/unit/Cron/Workers/SendingQueue/Tasks/PostsTest.php create mode 100644 tests/unit/Cron/Workers/SendingQueue/Tasks/ShortcodesTest.php create mode 100644 tests/unit/Cron/Workers/SendingQueue/Tasks/SubscribersTest.php diff --git a/tests/unit/Cron/Workers/SendingQueue/SendingQueueTest.php b/tests/unit/Cron/Workers/SendingQueue/SendingQueueTest.php new file mode 100644 index 0000000000..df6a38c944 --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/SendingQueueTest.php @@ -0,0 +1,316 @@ +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); + } +} \ No newline at end of file diff --git a/tests/unit/Cron/Workers/SendingQueue/Tasks/LinksTest.php b/tests/unit/Cron/Workers/SendingQueue/Tasks/LinksTest.php new file mode 100644 index 0000000000..1ccc23b28b --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/Tasks/LinksTest.php @@ -0,0 +1,60 @@ + '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' => 'Example Link', + 'text' => 'Example Link' + ); + $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' => 'Example Link', + 'text' => 'Example Link' + ); + $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); + } +} \ No newline at end of file diff --git a/tests/unit/Cron/Workers/SendingQueue/Tasks/MailerTest.php b/tests/unit/Cron/Workers/SendingQueue/Tasks/MailerTest.php new file mode 100644 index 0000000000..968cdd1514 --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/Tasks/MailerTest.php @@ -0,0 +1,124 @@ +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 '); + } + + 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); + } +} \ No newline at end of file diff --git a/tests/unit/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php b/tests/unit/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php new file mode 100644 index 0000000000..15f170ab46 --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php @@ -0,0 +1,171 @@ +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": "post_id . '\" href=\"http://example.com\">LinkHello [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); + } +} \ No newline at end of file diff --git a/tests/unit/Cron/Workers/SendingQueue/Tasks/PostsTest.php b/tests/unit/Cron/Workers/SendingQueue/Tasks/PostsTest.php new file mode 100644 index 0000000000..2fb4bee7b4 --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/Tasks/PostsTest.php @@ -0,0 +1,64 @@ +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' => 'sample post' + ) + ) + ); + 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' => 'sample post' + ) + ) + ); + 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); + } +} \ No newline at end of file diff --git a/tests/unit/Cron/Workers/SendingQueue/Tasks/ShortcodesTest.php b/tests/unit/Cron/Workers/SendingQueue/Tasks/ShortcodesTest.php new file mode 100644 index 0000000000..9dbfc229b1 --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/Tasks/ShortcodesTest.php @@ -0,0 +1,28 @@ + 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); + } +} \ No newline at end of file diff --git a/tests/unit/Cron/Workers/SendingQueue/Tasks/SubscribersTest.php b/tests/unit/Cron/Workers/SendingQueue/Tasks/SubscribersTest.php new file mode 100644 index 0000000000..c0f7b271f0 --- /dev/null +++ b/tests/unit/Cron/Workers/SendingQueue/Tasks/SubscribersTest.php @@ -0,0 +1,96 @@ +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 + ) + ) + ); + } +} \ No newline at end of file