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

Merge pull request #913 from mailpoet/sending_queue_update_on_newsletter_status_change

Browse Source 
Prevents processing of sending queues when newsletter is paused [MAILPOET-900]
This commit is contained in:
Tautvidas Sipavičius
2017-06-06 15:00:21 +03:00
committed by GitHub
parent 5af91d028d cdf36ccb20
commit 028de860a2
8 changed files with 435 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -31,6 +31,8 @@ class Scheduler {
->findOne($queue->newsletter_id);
if(!$newsletter || $newsletter->deleted_at !== null) {
$queue->delete();
} elseif($newsletter->status !== 'active') {
continue;
} elseif($newsletter->type === 'welcome') {
$this->processWelcomeNewsletter($newsletter, $queue);
} elseif($newsletter->type === 'notification') {

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

@ -6,10 +6,10 @@ use MailPoet\Cron\Workers\SendingQueue\Tasks\Links;
use MailPoet\Cron\Workers\SendingQueue\Tasks\Mailer as MailerTask;
use MailPoet\Cron\Workers\SendingQueue\Tasks\Newsletter as NewsletterTask;
use MailPoet\Mailer\MailerLog;
use MailPoet\Models\Newsletter as NewsletterModel;
use MailPoet\Models\SendingQueue as SendingQueueModel;
use MailPoet\Models\StatisticsNewsletters as StatisticsNewslettersModel;
use MailPoet\Models\Subscriber as SubscriberModel;
use MailPoet\Router\Endpoints\Track;
if(!defined('ABSPATH')) exit;
@ -28,8 +28,12 @@ class SendingQueue {
function process() {
$this->enforceSendingAndExecutionLimits();
foreach(self::getRunningQueues() as $queue) {
// get and pre-process newsletter (render, replace shortcodes/links, etc.)
$newsletter = $this->newsletter_task->getAndPreProcess($queue);
$newsletter = $this->newsletter_task->getNewsletterFromQueue($queue);
if(!$newsletter) {
continue;
}
// pre-process newsletter (render, replace shortcodes/links, etc.)
$newsletter = $this->newsletter_task->preProcessNewsletter($newsletter, $queue);
if(!$newsletter) {
$queue->delete();
continue;
@ -37,7 +41,7 @@ class SendingQueue {
// configure mailer
$this->mailer_task->configureMailer($newsletter);
// get newsletter segments
$newsletter_segments_ids = $this->newsletter_task->getSegments($newsletter);
$newsletter_segments_ids = $this->newsletter_task->getNewsletterSegments($newsletter);
// get subscribers
$queue->subscribers = $queue->getSubscribers();
$subscriber_batches = array_chunk(
@ -184,4 +188,4 @@ class SendingQueue {
->whereNull('type')
->findMany();
}
}
}

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

@ -22,11 +22,31 @@ class Newsletter {
$this->tracking_enabled = (boolean)Setting::getValue('tracking.enabled');
}
function getAndPreProcess($queue) {
$newsletter = $queue->newsletter()->whereNull('deleted_at')->findOne();
if(!$newsletter) {
return false;
function getNewsletterFromQueue($queue) {
// get existing active or sending newsletter
$newsletter = $queue->newsletter()
->whereNull('deleted_at')
->whereAnyIs(array(
array('status' => NewsletterModel::STATUS_ACTIVE),
array('status' => NewsletterModel::STATUS_SENDING)
))
->findOne();
if(!$newsletter) return false;
// if this is a notification history, get existing active or sending parent newsletter
if($newsletter->type == NewsletterModel::TYPE_NOTIFICATION_HISTORY) {
$parent_newsletter = $newsletter->parent()
->whereNull('deleted_at')
->whereAnyIs(array(
array('status' => NewsletterModel::STATUS_ACTIVE),
array('status' => NewsletterModel::STATUS_SENDING)
))
->findOne();
if(!$parent_newsletter) return false;
}
return $newsletter;
}
function preProcessNewsletter($newsletter, $queue) {
// return the newsletter if it was previously rendered
if(!is_null($queue->getNewsletterRenderedBody())) {
return $newsletter;
@ -113,7 +133,7 @@ class Newsletter {
}
}
function getSegments($newsletter) {
function getNewsletterSegments($newsletter) {
$segments = NewsletterSegmentModel::where('newsletter_id', $newsletter->id)
->select('segment_id')
->findArray();

147
lib/Models/Newsletter.php
View File

@ -39,6 +39,14 @@ class Newsletter extends Model {
);
}
function parent() {
return $this->hasOne(
__NAMESPACE__.'\Newsletter',
'id',
'parent_id'
);
}
function segments() {
return $this->hasManyThrough(
__NAMESPACE__.'\Segment',
@ -86,62 +94,111 @@ class Newsletter extends Model {
function trash() {
// trash queue associations
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `newsletter_id` = ' . $this->id
);
$children = $this->children()->select('id')->findArray();
if($children) {
$this->children()->rawExecute(
'UPDATE `' . self::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `parent_id` = ' . $this->id
);
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), array($this->id))) . ')'
);
} else {
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `newsletter_id` = ' . $this->id
);
}
return parent::trash();
}
static function bulkTrash($orm) {
// bulk trash queue associations
// bulk trash queue and notification history associations
parent::bulkAction($orm, function($ids) {
SendingQueue::rawExecute(join(' ', array(
'UPDATE `' . SendingQueue::$_table . '`',
'SET `deleted_at` = NOW()',
'WHERE `newsletter_id` IN (' . rtrim(str_repeat('?,', count($ids)), ',') . ')'
)),
$ids
);
$children = Newsletter::whereIn('parent_id', $ids)->select('id')->findArray();
if($children) {
Newsletter::rawExecute(
'UPDATE `' . Newsletter::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `parent_id` IN (' . join(',', Helpers::flattenArray($ids)) . ')'
);
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), $ids)) . ')'
);
} else {
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = NOW() ' .
'WHERE `newsletter_id` IN (' . join(',', Helpers::flattenArray($ids)) . ')'
);
}
});
return parent::bulkTrash($orm);
}
function delete() {
// delete segment associations
$this->segmentRelations()->deleteMany();
// delete queue associations
$this->queue()->deleteMany();
// delete queue, notification history and segment associations
$children = $this->children()->select('id')->findArray();
if($children) {
$children = Helpers::flattenArray($children);
$this->children()->deleteMany();
SendingQueue::whereIn('newsletter_id', array_merge($children, array($this->id)))->deleteMany();
NewsletterSegment::whereIn('newsletter_id', array_merge($children, array($this->id)))->deleteMany();
} else {
$this->queue()->deleteMany();
$this->segmentRelations()->deleteMany();
}
return parent::delete();
}
static function bulkDelete($orm) {
// bulk delete segment associations
// bulk delete queue, notification history and segment associations
parent::bulkAction($orm, function($ids) {
NewsletterSegment::whereIn('newsletter_id', $ids)
->deleteMany();
});
// bulk delete queue associations
parent::bulkAction($orm, function($ids) {
SendingQueue::whereIn('newsletter_id', $ids)
->deleteMany();
$children = Newsletter::whereIn('parent_id', $ids)->select('id')->findArray();
if($children) {
$children = Helpers::flattenArray($children);
Newsletter::whereIn('parent_id', $ids)->deleteMany();
SendingQueue::whereIn('newsletter_id', array_merge($children, $ids))->deleteMany();
NewsletterSegment::whereIn('newsletter_id', array_merge($children, $ids))->deleteMany();
} else {
SendingQueue::whereIn('newsletter_id', $ids)->deleteMany();
NewsletterSegment::whereIn('newsletter_id', $ids)->deleteMany();
}
});
return parent::bulkDelete($orm);
}
function restore() {
// restore trashed queue associations
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = null ' .
'WHERE `newsletter_id` = ' . $this->id
);
// restore trashed queue and notification history associations
$children = $this->children()->select('id')->findArray();
if($children) {
$this->children()->rawExecute(
'UPDATE `' . self::$_table . '` ' .
'SET `deleted_at` = null ' .
'WHERE `parent_id` = ' . $this->id
);
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = null ' .
'WHERE `newsletter_id` IN (' . join(',', array_merge(Helpers::flattenArray($children), array($this->id))) . ')'
);
} else {
SendingQueue::rawExecute(
'UPDATE `' . SendingQueue::$_table . '` ' .
'SET `deleted_at` = null ' .
'WHERE `newsletter_id` = ' . $this->id
);
}
if($this->status == self::STATUS_SENDING) {
$this->set('status', self::STATUS_DRAFT);
@ -151,13 +208,27 @@ class Newsletter extends Model {
}
static function bulkRestore($orm) {
// bulk restore trashed queue associations
// bulk restore trashed queue and notification history associations
parent::bulkAction($orm, function($ids) {
SendingQueue::whereIn('newsletter_id', $ids)
->whereNotNull('deleted_at')
->findResultSet()
->set('deleted_at', null)
->save();
$children = Newsletter::whereIn('parent_id', $ids)->select('id')->findArray();
if($children) {
Newsletter::whereIn('parent_id', $ids)
->whereNotNull('deleted_at')
->findResultSet()
->set('deleted_at', null)
->save();
SendingQueue::whereIn('newsletter_id', Helpers::flattenArray($children))
->whereNotNull('deleted_at')
->findResultSet()
->set('deleted_at', null)
->save();
} else {
SendingQueue::whereIn('newsletter_id', $ids)
->whereNotNull('deleted_at')
->findResultSet()
->set('deleted_at', null)
->save();
}
});
parent::bulkAction($orm, function($ids) {

16
tests/unit/Cron/Workers/SchedulerTest.php
View File

@ -503,6 +503,19 @@ class SchedulerTest extends MailPoetTest {
}
}
function testItDoesNotProcessScheduledJobsWhenNewsletterIsNotActive() {
$newsletter = $this->_createNewsletter(Newsletter::TYPE_STANDARD, Newsletter::STATUS_DRAFT);
$queue = $this->_createQueue($newsletter->id);
$queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
$queue->save();
$scheduler = Stub::make(new Scheduler(), array(
'processScheduledStandardNewsletter' => Stub::never()
), $this);
// scheduled job is not processed
$scheduler->process();
}
function _createNewsletterSegment($newsletter_id, $segment_id) {
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->newsletter_id = $newsletter_id;
@ -544,9 +557,10 @@ class SchedulerTest extends MailPoetTest {
return $subscriber;
}
function _createNewsletter($type = Newsletter::TYPE_NOTIFICATION) {
function _createNewsletter($type = Newsletter::TYPE_NOTIFICATION, $status = 'active') {
$newsletter = Newsletter::create();
$newsletter->type = $type;
$newsletter->status = $status;
$newsletter->save();
expect($newsletter->getErrors())->false();
return $newsletter;

1
tests/unit/Cron/Workers/SendingQueue/SendingQueueTest.php
View File

@ -43,6 +43,7 @@ class SendingQueueTest extends MailPoetTest {
$this->subscriber_segment->save();
$this->newsletter = Newsletter::create();
$this->newsletter->type = Newsletter::TYPE_STANDARD;
$this->newsletter->status = Newsletter::STATUS_ACTIVE;
$this->newsletter->subject = Fixtures::get('newsletter_subject_template');
$this->newsletter->body = Fixtures::get('newsletter_body_template');
$this->newsletter->save();

100
tests/unit/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
View File

@ -22,9 +22,18 @@ class NewsletterTaskTest extends MailPoetTest {
$this->subscriber->save();
$this->newsletter = Newsletter::create();
$this->newsletter->type = Newsletter::TYPE_STANDARD;
$this->newsletter->status = Newsletter::STATUS_ACTIVE;
$this->newsletter->subject = Fixtures::get('newsletter_subject_template');
$this->newsletter->body = Fixtures::get('newsletter_body_template');
$this->newsletter->preheader = '';
$this->newsletter->save();
$this->parent_newsletter = Newsletter::create();
$this->parent_newsletter->type = Newsletter::TYPE_STANDARD;
$this->parent_newsletter->status = Newsletter::STATUS_ACTIVE;
$this->parent_newsletter->subject = 'parent newsletter';
$this->parent_newsletter->body = 'parent body';
$this->parent_newsletter->preheader = '';
$this->parent_newsletter->save();
$this->queue = SendingQueue::create();
$this->queue->newsletter_id = $this->newsletter->id;
$this->queue->save();
@ -34,16 +43,78 @@ class NewsletterTaskTest extends MailPoetTest {
expect($this->newsletter_task->tracking_enabled)->true();
}
function testItFailsToGetAndProcessNewsletterWhenNewsletterDoesNotExist() {
$queue = $this->queue;
$queue->newsletter_id = 0;
expect($this->newsletter_task->getAndPreProcess($queue))->false();
function testItDoesNotGetNewsletterWhenStatusIsNotActiveOrSending() {
// draft or any other status return false
$newsletter = $this->newsletter;
$newsletter->status = Newsletter::STATUS_DRAFT;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->false();
// active or sending statuses return newsletter
$newsletter = $this->newsletter;
$newsletter->status = Newsletter::STATUS_ACTIVE;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->isInstanceOf('Mailpoet\Models\Newsletter');
$newsletter = $this->newsletter;
$newsletter->status = Newsletter::STATUS_SENDING;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->isInstanceOf('Mailpoet\Models\Newsletter');
}
function testItReturnsNewsletterObjectWhenRenderedNewssletterBodyExistsInTheQueue() {
function testItDoesNotGetDeletedNewsletter() {
$newsletter = $this->newsletter;
$newsletter->set_expr('deleted_at', 'NOW()');
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->false();
}
function testItDoesNotGetNewsletterWhenParentNewsletterStatusIsNotActiveOrSending() {
// draft or any other status return false
$parent_newsletter = $this->parent_newsletter;
$parent_newsletter->status = Newsletter::STATUS_DRAFT;
$parent_newsletter->save();
$newsletter = $this->newsletter;
$newsletter->type = Newsletter::TYPE_NOTIFICATION_HISTORY;
$newsletter->parent_id = $parent_newsletter->id;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->false();
// active or sending statuses return newsletter
$parent_newsletter = $this->parent_newsletter;
$parent_newsletter->status = Newsletter::STATUS_ACTIVE;
$parent_newsletter->save();
$newsletter = $this->newsletter;
$newsletter->type = Newsletter::TYPE_NOTIFICATION_HISTORY;
$newsletter->parent_id = $parent_newsletter->id;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->isInstanceOf('Mailpoet\Models\Newsletter');
$parent_newsletter = $this->parent_newsletter;
$parent_newsletter->status = Newsletter::STATUS_SENDING;
$parent_newsletter->save();
$newsletter = $this->newsletter;
$newsletter->type = Newsletter::TYPE_NOTIFICATION_HISTORY;
$newsletter->parent_id = $parent_newsletter->id;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->isInstanceOf('Mailpoet\Models\Newsletter');
}
function testItDoesNotGetDeletedNewsletterWhenParentNewsletterIsDeleted() {
$parent_newsletter = $this->parent_newsletter;
$parent_newsletter->set_expr('deleted_at', 'NOW()');
$parent_newsletter->save();
$newsletter = $this->newsletter;
$newsletter->type = Newsletter::TYPE_NOTIFICATION_HISTORY;
$newsletter->parent_id = $parent_newsletter->id;
$newsletter->save();
expect($this->newsletter_task->getNewsletterFromQueue($this->queue))->false();
}
function testItReturnsNewsletterObjectWhenRenderedNewsletterBodyExistsInTheQueue() {
$queue = $this->queue;
$queue->newsletter_rendered_body = true;
$result = $this->newsletter_task->getAndPreProcess($queue);
$result = $this->newsletter_task->preProcessNewsletter($this->newsletter, $queue);
expect($result instanceof \MailPoet\Models\Newsletter)->true();
}
@ -51,7 +122,7 @@ class NewsletterTaskTest extends MailPoetTest {
WPHooksHelper::interceptApplyFilters();
$newsletter_task = $this->newsletter_task;
$newsletter_task->tracking_enabled = true;
$newsletter_task->getAndPreProcess($this->queue);
$newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);
$link = NewsletterLink::where('newsletter_id', $this->newsletter->id)
->findOne();
$updated_queue = SendingQueue::findOne($this->queue->id);
@ -71,7 +142,7 @@ class NewsletterTaskTest extends MailPoetTest {
WPHooksHelper::interceptApplyFilters();
$newsletter_task = $this->newsletter_task;
$newsletter_task->tracking_enabled = false;
$newsletter_task->getAndPreProcess($this->queue);
$newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);
$link = NewsletterLink::where('newsletter_id', $this->newsletter->id)
->findOne();
expect($link)->false();
@ -88,15 +159,16 @@ class NewsletterTaskTest extends MailPoetTest {
expect(WPHooksHelper::getFilterApplied($hook_name)[1] instanceof Newsletter)->true();
}
function testItReturnsFalseAndDeletesNewsletterWhenPostNotificationContainsNoPostsn() {
function testItReturnsFalseAndDeletesNewsletterWhenPostNotificationContainsNoPosts() {
$newsletter = $this->newsletter;
$newsletter->type = Newsletter::TYPE_NOTIFICATION_HISTORY;
$newsletter->parent_id = $newsletter->id;
// replace post id data tag with something else
$newsletter->body = str_replace('data-post-id', 'id', $newsletter->body);
$newsletter->save();
// returned result is false
$result = $this->newsletter_task->getAndPreProcess($this->queue);
$result = $this->newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);
expect($result)->false();
// newsletter is deleted
$newsletter = Newsletter::findOne($newsletter->id);
@ -104,7 +176,7 @@ class NewsletterTaskTest extends MailPoetTest {
}
function testItSavesNewsletterPosts() {
$result = $this->newsletter_task->getAndPreProcess($this->queue);
$result = $this->newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);
$newsletter_post = NewsletterPost::where('newsletter_id', $this->newsletter->id)
->findOne();
expect($result)->notEquals(false);
@ -140,7 +212,7 @@ class NewsletterTaskTest extends MailPoetTest {
}
function testItRendersShortcodesAndReplacesSubscriberDataInLinks() {
$newsletter = $this->newsletter_task->getAndPreProcess($this->queue);
$newsletter = $this->newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);
$result = $this->newsletter_task->prepareNewsletterForSending(
$newsletter,
$this->subscriber,
@ -156,7 +228,7 @@ class NewsletterTaskTest extends MailPoetTest {
function testItDoesNotReplaceSubscriberDataInLinksWhenTrackingIsNotEnabled() {
$newsletter_task = $this->newsletter_task;
$newsletter_task->tracking_enabled = false;
$newsletter = $newsletter_task->getAndPreProcess($this->queue);
$newsletter = $newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);
$result = $newsletter_task->prepareNewsletterForSending(
$newsletter,
$this->subscriber,
@ -175,7 +247,7 @@ class NewsletterTaskTest extends MailPoetTest {
$newsletter_segment->segment_id = $i;
$newsletter_segment->save();
}
expect($this->newsletter_task->getSegments($this->newsletter))->equals(
expect($this->newsletter_task->getNewsletterSegments($this->newsletter))->equals(
array(1,2,3)
);
}

188
tests/unit/Models/NewsletterTest.php
View File

@ -109,6 +109,19 @@ class NewsletterTest extends MailPoetTest {
expect($newsletter_segments[1]['name'])->equals('Segment 2');
}
function testItCanHaveParentNewsletter() {
$parent_newsletter = Newsletter::create();
$parent_newsletter->type = Newsletter::TYPE_NOTIFICATION;
$parent_newsletter->save();
$newsletter = $this->newsletter;
$newsletter->type = Newsletter::TYPE_NOTIFICATION_HISTORY;
$newsletter->parent_id = $parent_newsletter->id;
$newsletter->save();
$parent = $newsletter->parent()->findOne();
expect($parent)->isInstanceOf('MailPoet\Models\Newsletter');
expect($parent->id)->equals($parent_newsletter->id);
}
function testItCanHaveDeletedSegments() {
$this->segment_2->delete();
$this->newsletter->withSegments(true);
@ -446,6 +459,39 @@ class NewsletterTest extends MailPoetTest {
expect($newsletter_segments)->isEmpty();
}
function testItDeletesChildrenSegmentAndQueueAssociationsWhenParentNewsletterIsDeleted() {
$parent_newsletter = $this->newsletter;
// create multiple children (post notification history) newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
$newsletter = Newsletter::createOrUpdate(
array(
'subject' => 'test',
'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
'parent_id' => $parent_newsletter->id
)
);
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->save();
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->newsletter_id = $newsletter->id;
$newsletter_segment->segment_id = 1;
$newsletter_segment->save();
}
// make sure relations exist
// 1 parent newsletter/queues, 2 parent segments and 5 children queues/newsletters/segments
expect(Newsletter::findArray())->count(6);
expect(SendingQueue::findArray())->count(6);
expect(NewsletterSegment::findArray())->count(7);
// delete parent newsletter and check that relations no longer exist
$parent_newsletter->delete();
expect(Newsletter::findArray())->count(0);
expect(SendingQueue::findArray())->count(0);
expect(NewsletterSegment::findArray())->count(0);
}
function testItTrashesQueueAssociationsWhenNewsletterIsTrashed() {
// create multiple sending queues
$newsletter = $this->newsletter;
@ -462,6 +508,32 @@ class NewsletterTest extends MailPoetTest {
expect(SendingQueue::whereNotNull('deleted_at')->findArray())->count(6);
}
function testItTrashesChildrenQueueAssociationsWhenParentNewsletterIsTrashed() {
$parent_newsletter = $this->newsletter;
// create multiple children (post notification history) newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
$newsletter = Newsletter::createOrUpdate(
array(
'subject' => 'test',
'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
'parent_id' => $parent_newsletter->id
)
);
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->save();
}
// 1 parent and 5 children queues/newsletters
expect(Newsletter::whereNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNull('deleted_at')->findArray())->count(6);
// trash parent newsletter and check that relations are trashed
$parent_newsletter->trash();
// 1 parent and 5 children queues/newsletters
expect(Newsletter::whereNotNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNotNull('deleted_at')->findArray())->count(6);
}
function testItRestoresTrashedQueueAssociationsWhenNewsletterIsRestored() {
// create multiple sending queues
$newsletter = $this->newsletter;
@ -479,6 +551,41 @@ class NewsletterTest extends MailPoetTest {
expect(SendingQueue::whereNull('deleted_at')->findArray())->count(6);
}
function testItRestoresTrashedChildrenQueueAssociationsWhenParentNewsletterIsRestored() {
// delete parent newsletter and sending queue
$parent_newsletter = $this->newsletter;
$parent_newsletter->deleted_at = date('Y-m-d H:i:s');
$parent_newsletter->save();
$parent_sending_queue = $this->sending_queue;
$parent_sending_queue->deleted_at = date('Y-m-d H:i:s');
$parent_sending_queue->save();
// create multiple children (post notification history) newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
$newsletter = Newsletter::createOrUpdate(
array(
'subject' => 'test',
'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
'parent_id' => $parent_newsletter->id,
'deleted_at' => date('Y-m-d H:i:s')
)
);
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->deleted_at = date('Y-m-d H:i:s');
$sending_queue->save();
}
// 1 parent and 5 children queues/newsletters
expect(Newsletter::whereNotNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNotNull('deleted_at')->findArray())->count(6);
// restore parent newsletter and check that relations are restored
$parent_newsletter->restore();
// 1 parent and 5 children queues/newsletters
expect(Newsletter::whereNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNull('deleted_at')->findArray())->count(6);
}
function testItTrashesAllQueueAssociationsWhenNewslettersAreBulkTrashed() {
// create multiple newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
@ -502,6 +609,30 @@ class NewsletterTest extends MailPoetTest {
expect(SendingQueue::whereNotNull('deleted_at')->findArray())->count(6);
}
function testItTrashesAllChildrenQueueAssociationsWhenParentNewslettersAreBulkTrashed() {
// create multiple children (post notification history) newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
$newsletter = Newsletter::createOrUpdate(
array(
'subject' => 'test',
'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
'parent_id' => $this->newsletter->id,
)
);
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->save();
}
// 5 queues/newsletters + 1 of each created in _before() method
expect(Newsletter::whereNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNull('deleted_at')->findArray())->count(6);
// bulk trash parent newsletters and check that relations are trashed
Newsletter::bulkTrash(ORM::forTable(Newsletter::$_table));
expect(Newsletter::whereNotNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNotNull('deleted_at')->findArray())->count(6);
}
function testItBulkRestoresTrashedQueueAssociationsWhenNewslettersAreBulkRestored() {
// create multiple newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
@ -527,6 +658,32 @@ class NewsletterTest extends MailPoetTest {
expect(SendingQueue::whereNull('deleted_at')->findArray())->count(6);
}
function testItBulkRestoresTrashedChildrenQueueAssociationsWhenParentNewslettersAreBulkRestored() {
// create multiple children (post notification history) newsletters and sending queues
for($i = 1; $i <= 5; $i++) {
$newsletter = Newsletter::createOrUpdate(
array(
'subject' => 'test',
'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
'parent_id' => $this->newsletter->id,
'deleted_at' => date('Y-m-d H:i:s')
)
);
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->deleted_at = date('Y-m-d H:i:s');
$sending_queue->save();
}
expect(Newsletter::whereNotNull('deleted_at')->findArray())->count(5);
expect(SendingQueue::whereNotNull('deleted_at')->findArray())->count(5);
// bulk restore parent newsletters and check that relations are restored
Newsletter::bulkRestore(ORM::forTable(Newsletter::$_table));
// 1 parent and 5 queues/newsletters
expect(Newsletter::whereNull('deleted_at')->findArray())->count(6);
expect(SendingQueue::whereNull('deleted_at')->findArray())->count(6);
}
function testItBulkDeletesSegmentAndQueueAssociationsWhenNewslettersAreBulkDeleted() {
// create multiple newsletters, sending queues and newsletter segments
for($i = 1; $i <= 5; $i++) {
@ -557,6 +714,37 @@ class NewsletterTest extends MailPoetTest {
expect(NewsletterSegment::findArray())->count(0);
}
function testItBulkDeletesChildrenSegmentAndQueueAssociationsWhenParentNewslettersAreBulkDeleted() {
$this->_after();
// create multiple children (post notification history) newsletters, sending queues and newsletter segments
for($i = 1; $i <= 5; $i++) {
$newsletter = Newsletter::createOrUpdate(
array(
'subject' => 'test',
'type' => Newsletter::TYPE_NOTIFICATION_HISTORY,
'parent_id' => $this->newsletter->id
)
);
$sending_queue = SendingQueue::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->save();
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->newsletter_id = $newsletter->id;
$newsletter_segment->segment_id = 1;
$newsletter_segment->save();
}
// 5 queues/newsletters/segment associations
expect(Newsletter::findArray())->count(5);
expect(SendingQueue::findArray())->count(5);
expect(NewsletterSegment::findArray())->count(5);
// bulk delete newsletters and check that relations are deleted
Newsletter::bulkDelete(ORM::forTable(Newsletter::$_table));
expect(Newsletter::findArray())->count(0);
expect(SendingQueue::findArray())->count(0);
expect(NewsletterSegment::findArray())->count(0);
}
function _after() {
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);