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

Convert variable names to camel case

Browse Source 
[MAILPOET-1796]
This commit is contained in:
Jan Jakeš
2020-01-09 15:02:58 +01:00
committed by Jan Jakeš
parent f5da704106
commit 54549ff037
687 changed files with 15890 additions and 15887 deletions
Download Patch File Download Diff File Expand all files Collapse all files

446
tests/integration/API/JSON/v1/NewslettersTest.php
View File

@@ -54,8 +54,8 @@ class NewslettersTest extends \MailPoetTest {
public function _before() {
parent::_before();
$this->subscription_url_factory = SubscriptionUrlFactory::getInstance();
$this->cron_helper = ContainerWrapper::getInstance()->get(CronHelper::class);
$this->subscriptionUrlFactory = SubscriptionUrlFactory::getInstance();
$this->cronHelper = ContainerWrapper::getInstance()->get(CronHelper::class);
$this->endpoint = ContainerWrapper::getInstance()->get(Newsletters::class);
$this->newsletter = Newsletter::createOrUpdate(
[
@@ -64,7 +64,7 @@ class NewslettersTest extends \MailPoetTest {
'type' => Newsletter::TYPE_STANDARD,
]);
$this->post_notification = Newsletter::createOrUpdate(
$this->postNotification = Newsletter::createOrUpdate(
[
'subject' => 'My Post Notification',
'body' => Fixtures::get('newsletter_body_template'),
@@ -84,13 +84,13 @@ class NewslettersTest extends \MailPoetTest {
}
public function testItKeepsUnsentNewslettersAtTheTopWhenSortingBySentAtDate() {
$sent_newsletters = [];
$sentNewsletters = [];
for ($i = 1; $i <= 3; $i++) {
$sent_newsletters[$i] = Newsletter::create();
$sent_newsletters[$i]->type = Newsletter::TYPE_STANDARD;
$sent_newsletters[$i]->subject = 'Sent newsletter ' . $i;
$sent_newsletters[$i]->sent_at = '2017-01-0' . $i . ' 01:01:01';
$sent_newsletters[$i]->save();
$sentNewsletters[$i] = Newsletter::create();
$sentNewsletters[$i]->type = Newsletter::TYPE_STANDARD;
$sentNewsletters[$i]->subject = 'Sent newsletter ' . $i;
$sentNewsletters[$i]->sent_at = '2017-01-0' . $i . ' 01:01:01';
$sentNewsletters[$i]->save();
};
// sorting by ASC order retains unsent newsletters at the top
@@ -105,9 +105,9 @@ class NewslettersTest extends \MailPoetTest {
);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->data[0]['id'])->equals($this->newsletter->id);
expect($response->data[1]['id'])->equals($sent_newsletters[1]->id);
expect($response->data[2]['id'])->equals($sent_newsletters[2]->id);
expect($response->data[3]['id'])->equals($sent_newsletters[3]->id);
expect($response->data[1]['id'])->equals($sentNewsletters[1]->id);
expect($response->data[2]['id'])->equals($sentNewsletters[2]->id);
expect($response->data[3]['id'])->equals($sentNewsletters[3]->id);
// sorting by DESC order retains unsent newsletters at the top
$response = $this->endpoint->listing(
@@ -121,9 +121,9 @@ class NewslettersTest extends \MailPoetTest {
);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->data[0]['id'])->equals($this->newsletter->id);
expect($response->data[1]['id'])->equals($sent_newsletters[3]->id);
expect($response->data[2]['id'])->equals($sent_newsletters[2]->id);
expect($response->data[3]['id'])->equals($sent_newsletters[1]->id);
expect($response->data[1]['id'])->equals($sentNewsletters[3]->id);
expect($response->data[2]['id'])->equals($sentNewsletters[2]->id);
expect($response->data[3]['id'])->equals($sentNewsletters[1]->id);
}
public function testItCanGetANewsletter() {
@@ -146,7 +146,7 @@ class NewslettersTest extends \MailPoetTest {
$wp,
$this->makeEmpty(WCHelper::class),
SettingsController::getInstance(),
$this->cron_helper,
$this->cronHelper,
$this->make(AuthorizedEmailsController::class, ['onNewsletterUpdate' => Expected::never()]),
ContainerWrapper::getInstance()->get(NewslettersRepository::class),
ContainerWrapper::getInstance()->get(NewslettersResponseBuilder::class),
@@ -165,22 +165,22 @@ class NewslettersTest extends \MailPoetTest {
->withSendingQueue()
->asArray()
);
$hook_name = 'mailpoet_api_newsletters_get_after';
expect(WPHooksHelper::isFilterApplied($hook_name))->true();
expect(WPHooksHelper::getFilterApplied($hook_name)[0])->internalType('array');
$hookName = 'mailpoet_api_newsletters_get_after';
expect(WPHooksHelper::isFilterApplied($hookName))->true();
expect(WPHooksHelper::getFilterApplied($hookName)[0])->internalType('array');
}
public function testItCanSaveANewNewsletter() {
$newsletter_option_field = NewsletterOptionField::create();
$newsletter_option_field->name = 'some_option';
$newsletter_option_field->newsletter_type = Newsletter::TYPE_STANDARD;
$newsletter_option_field->save();
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = 'some_option';
$newsletterOptionField->newsletterType = Newsletter::TYPE_STANDARD;
$newsletterOptionField->save();
$valid_data = [
$validData = [
'subject' => 'My First Newsletter',
'type' => Newsletter::TYPE_STANDARD,
'options' => [
$newsletter_option_field->name => 'some_option_value',
$newsletterOptionField->name => 'some_option_value',
],
'body' => 'some text',
];
@@ -202,7 +202,7 @@ class NewslettersTest extends \MailPoetTest {
$wp,
$this->makeEmpty(WCHelper::class),
SettingsController::getInstance(),
$this->cron_helper,
$this->cronHelper,
$this->make(AuthorizedEmailsController::class, ['onNewsletterUpdate' => Expected::once()]),
ContainerWrapper::getInstance()->get(NewslettersRepository::class),
ContainerWrapper::getInstance()->get(NewslettersResponseBuilder::class),
@@ -213,97 +213,97 @@ class NewslettersTest extends \MailPoetTest {
Stub::make(SubscribersFeature::class)
);
$response = $this->endpoint->save($valid_data);
$saved_newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_STANDARD)
$response = $this->endpoint->save($validData);
$savedNewsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_STANDARD)
->findOne($response->data['id']);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->data)->equals($saved_newsletter->asArray());
expect($response->data)->equals($savedNewsletter->asArray());
// newsletter option should be saved
expect($saved_newsletter->some_option)->equals('some_option_value');
expect(strlen($saved_newsletter->unsubscribe_token))->equals(15);
expect($savedNewsletter->someOption)->equals('some_option_value');
expect(strlen($savedNewsletter->unsubscribeToken))->equals(15);
$hook_name = 'mailpoet_api_newsletters_save_before';
expect(WPHooksHelper::isFilterApplied($hook_name))->true();
expect(WPHooksHelper::getFilterApplied($hook_name)[0])->internalType('array');
$hook_name = 'mailpoet_api_newsletters_save_after';
expect(WPHooksHelper::isActionDone($hook_name))->true();
expect(WPHooksHelper::getActionDone($hook_name)[0] instanceof Newsletter)->true();
$hookName = 'mailpoet_api_newsletters_save_before';
expect(WPHooksHelper::isFilterApplied($hookName))->true();
expect(WPHooksHelper::getFilterApplied($hookName)[0])->internalType('array');
$hookName = 'mailpoet_api_newsletters_save_after';
expect(WPHooksHelper::isActionDone($hookName))->true();
expect(WPHooksHelper::getActionDone($hookName)[0] instanceof Newsletter)->true();
$invalid_data = [
$invalidData = [
'subject' => 'Missing newsletter type',
];
$response = $this->endpoint->save($invalid_data);
$response = $this->endpoint->save($invalidData);
expect($response->status)->equals(APIResponse::STATUS_BAD_REQUEST);
expect($response->errors[0]['message'])->equals('Please specify a type.');
}
public function testItCanSaveAnExistingNewsletter() {
$newsletter_data = [
$newsletterData = [
'id' => $this->newsletter->id,
'subject' => 'My Updated Newsletter',
];
$response = $this->endpoint->save($newsletter_data);
$updated_newsletter = Newsletter::findOne($this->newsletter->id);
$response = $this->endpoint->save($newsletterData);
$updatedNewsletter = Newsletter::findOne($this->newsletter->id);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->data)->equals($updated_newsletter->asArray());
expect($updated_newsletter->subject)->equals('My Updated Newsletter');
expect($response->data)->equals($updatedNewsletter->asArray());
expect($updatedNewsletter->subject)->equals('My Updated Newsletter');
}
public function testItDoesNotRerenderPostNotificationsUponUpdate() {
$sending_queue = SendingTask::create();
$sending_queue->newsletter_id = $this->post_notification->id;
$sending_queue->status = SendingQueue::STATUS_SCHEDULED;
$sending_queue->newsletter_rendered_body = null;
$sending_queue->newsletter_rendered_subject = null;
$sending_queue->save();
expect($sending_queue->getErrors())->false();
$sendingQueue = SendingTask::create();
$sendingQueue->newsletterId = $this->postNotification->id;
$sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue->newsletterRenderedBody = null;
$sendingQueue->newsletterRenderedSubject = null;
$sendingQueue->save();
expect($sendingQueue->getErrors())->false();
$newsletter_data = [
'id' => $this->post_notification->id,
$newsletterData = [
'id' => $this->postNotification->id,
'subject' => 'My Updated Newsletter',
'body' => Fixtures::get('newsletter_body_template'),
];
$response = $this->endpoint->save($newsletter_data);
$updated_queue = SendingQueue::where('newsletter_id', $this->post_notification->id)
$response = $this->endpoint->save($newsletterData);
$updatedQueue = SendingQueue::where('newsletter_id', $this->postNotification->id)
->findOne()
->asArray();
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($updated_queue['newsletter_rendered_body'])->null();
expect($updated_queue['newsletter_rendered_subject'])->null();
expect($updatedQueue['newsletter_rendered_body'])->null();
expect($updatedQueue['newsletter_rendered_subject'])->null();
}
public function testItCanRerenderQueueUponSave() {
$sending_queue = SendingTask::create();
$sending_queue->newsletter_id = $this->newsletter->id;
$sending_queue->status = SendingQueue::STATUS_SCHEDULED;
$sending_queue->newsletter_rendered_body = null;
$sending_queue->newsletter_rendered_subject = null;
$sending_queue->save();
expect($sending_queue->getErrors())->false();
$sendingQueue = SendingTask::create();
$sendingQueue->newsletterId = $this->newsletter->id;
$sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue->newsletterRenderedBody = null;
$sendingQueue->newsletterRenderedSubject = null;
$sendingQueue->save();
expect($sendingQueue->getErrors())->false();
$newsletter_data = [
$newsletterData = [
'id' => $this->newsletter->id,
'subject' => 'My Updated Newsletter',
'body' => Fixtures::get('newsletter_body_template'),
];
$response = $this->endpoint->save($newsletter_data);
$updated_queue = SendingQueue::where('newsletter_id', $this->newsletter->id)
$response = $this->endpoint->save($newsletterData);
$updatedQueue = SendingQueue::where('newsletter_id', $this->newsletter->id)
->findOne()
->asArray();
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($updated_queue['newsletter_rendered_body'])->hasKey('html');
expect($updated_queue['newsletter_rendered_body'])->hasKey('text');
expect($updated_queue['newsletter_rendered_subject'])->equals('My Updated Newsletter');
expect($updatedQueue['newsletter_rendered_body'])->hasKey('html');
expect($updatedQueue['newsletter_rendered_body'])->hasKey('text');
expect($updatedQueue['newsletter_rendered_subject'])->equals('My Updated Newsletter');
}
public function testItCanUpdatePostNotificationScheduleUponSave() {
$newsletter_options = [
$newsletterOptions = [
'intervalType',
'timeOfDay',
'weekDay',
@@ -311,14 +311,14 @@ class NewslettersTest extends \MailPoetTest {
'nthWeekDay',
'schedule',
];
foreach ($newsletter_options as $option) {
$newsletter_option_field = NewsletterOptionField::create();
$newsletter_option_field->name = $option;
$newsletter_option_field->newsletter_type = Newsletter::TYPE_NOTIFICATION;
$newsletter_option_field->save();
foreach ($newsletterOptions as $option) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $option;
$newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
$newsletterOptionField->save();
}
$newsletter_data = [
$newsletterData = [
'id' => $this->newsletter->id,
'type' => Newsletter::TYPE_NOTIFICATION,
'subject' => 'Newsletter',
@@ -331,24 +331,24 @@ class NewslettersTest extends \MailPoetTest {
'schedule' => '0 14 * * 1',
],
];
$response = $this->endpoint->save($newsletter_data);
$saved_newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
$response = $this->endpoint->save($newsletterData);
$savedNewsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($response->data['id']);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->data)->equals($saved_newsletter->asArray());
expect($response->data)->equals($savedNewsletter->asArray());
// schedule should be recalculated when options change
$newsletter_data['options']['intervalType'] = PostNotificationScheduler::INTERVAL_IMMEDIATELY;
$response = $this->endpoint->save($newsletter_data);
$saved_newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
$newsletterData['options']['intervalType'] = PostNotificationScheduler::INTERVAL_IMMEDIATELY;
$response = $this->endpoint->save($newsletterData);
$savedNewsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($response->data['id']);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($saved_newsletter->schedule)->equals('* * * * *');
expect($savedNewsletter->schedule)->equals('* * * * *');
}
public function testItCanReschedulePreviouslyScheduledSendingQueueJobs() {
// create newsletter options
$newsletter_options = [
$newsletterOptions = [
'intervalType',
'timeOfDay',
'weekDay',
@@ -356,27 +356,27 @@ class NewslettersTest extends \MailPoetTest {
'nthWeekDay',
'schedule',
];
foreach ($newsletter_options as $option) {
$newsletter_option_field = NewsletterOptionField::create();
$newsletter_option_field->name = $option;
$newsletter_option_field->newsletter_type = Newsletter::TYPE_NOTIFICATION;
$newsletter_option_field->save();
foreach ($newsletterOptions as $option) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $option;
$newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
$newsletterOptionField->save();
}
// create sending queues
$current_time = Carbon::now();
$sending_queue_1 = SendingTask::create();
$sending_queue_1->newsletter_id = 1;
$sending_queue_1->status = SendingQueue::STATUS_SCHEDULED;
$sending_queue_1->scheduled_at = $current_time;
$sending_queue_1->save();
$currentTime = Carbon::now();
$sendingQueue1 = SendingTask::create();
$sendingQueue1->newsletterId = 1;
$sendingQueue1->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue1->scheduledAt = $currentTime;
$sendingQueue1->save();
$sending_queue_2 = SendingTask::create();
$sending_queue_2->newsletter_id = 1;
$sending_queue_2->save();
$sendingQueue2 = SendingTask::create();
$sendingQueue2->newsletterId = 1;
$sendingQueue2->save();
// save newsletter via router
$newsletter_data = [
$newsletterData = [
'id' => 1,
'type' => Newsletter::TYPE_NOTIFICATION,
'subject' => 'Newsletter',
@@ -390,42 +390,42 @@ class NewslettersTest extends \MailPoetTest {
'schedule' => '0 7 * * 1',
],
];
$newsletter = $this->endpoint->save($newsletter_data);
$newsletter = $this->endpoint->save($newsletterData);
/** @var SendingQueue $sending_queue_1 */
$sending_queue_1 = SendingQueue::findOne($sending_queue_1->id);
$sending_queue_1 = SendingTask::createFromQueue($sending_queue_1);
$sendingQueue1 = SendingQueue::findOne($sendingQueue1->id);
$sendingQueue1 = SendingTask::createFromQueue($sendingQueue1);
/** @var SendingQueue $sending_queue_2 */
$sending_queue_2 = SendingQueue::findOne($sending_queue_2->id);
$sending_queue_2 = SendingTask::createFromQueue($sending_queue_2);
expect($sending_queue_1->scheduled_at)->notEquals($current_time);
expect($sending_queue_1->scheduled_at)->equals(
$sendingQueue2 = SendingQueue::findOne($sendingQueue2->id);
$sendingQueue2 = SendingTask::createFromQueue($sendingQueue2);
expect($sendingQueue1->scheduledAt)->notEquals($currentTime);
expect($sendingQueue1->scheduledAt)->equals(
Scheduler::getNextRunDate($newsletter->data['schedule'])
);
expect($sending_queue_2->scheduled_at)->null();
expect($sendingQueue2->scheduledAt)->null();
}
public function testItCanModifySegmentsOfExistingNewsletter() {
$segment_1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$fake_segment_id = 1;
$segment1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$fakeSegmentId = 1;
$newsletter_data = [
$newsletterData = [
'id' => $this->newsletter->id,
'subject' => 'My Updated Newsletter',
'segments' => [
$segment_1->asArray(),
$fake_segment_id,
$segment1->asArray(),
$fakeSegmentId,
],
];
$response = $this->endpoint->save($newsletter_data);
$response = $this->endpoint->save($newsletterData);
expect($response->status)->equals(APIResponse::STATUS_OK);
$updated_newsletter =
$updatedNewsletter =
Newsletter::findOne($this->newsletter->id)
->withSegments();
expect(count($updated_newsletter->segments))->equals(1);
expect($updated_newsletter->segments[0]['name'])->equals('Segment 1');
expect(count($updatedNewsletter->segments))->equals(1);
expect($updatedNewsletter->segments[0]['name'])->equals('Segment 1');
}
public function testItReturnsErrorIfSubscribersLimitReached() {
@@ -435,7 +435,7 @@ class NewslettersTest extends \MailPoetTest {
ContainerWrapper::getInstance()->get(WPFunctions::class),
$this->makeEmpty(WCHelper::class),
SettingsController::getInstance(),
$this->cron_helper,
$this->cronHelper,
$this->make(AuthorizedEmailsController::class),
ContainerWrapper::getInstance()->get(NewslettersRepository::class),
ContainerWrapper::getInstance()->get(NewslettersResponseBuilder::class),
@@ -495,37 +495,37 @@ class NewslettersTest extends \MailPoetTest {
}
public function testItReschedulesPastDuePostNotificationsWhenStatusIsSetBackToActive() {
$newsletter_option_field = NewsletterOptionField::create();
$newsletter_option_field->name = 'schedule';
$newsletter_option_field->newsletter_type = Newsletter::TYPE_NOTIFICATION;
$newsletter_option_field->save();
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = 'schedule';
$newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
$newsletterOptionField->save();
$schedule = sprintf('0 %d * * *', Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->hour); // every day at current hour
$random_future_date = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->addDays(10)->format('Y-m-d H:i:s'); // 10 days from now
$newsletter_option = NewsletterOption::createOrUpdate(
$randomFutureDate = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->addDays(10)->format('Y-m-d H:i:s'); // 10 days from now
$newsletterOption = NewsletterOption::createOrUpdate(
[
'newsletter_id' => $this->post_notification->id,
'option_field_id' => $newsletter_option_field->id,
'newsletter_id' => $this->postNotification->id,
'option_field_id' => $newsletterOptionField->id,
'value' => $schedule,
]
);
$sending_queue_1 = SendingTask::create();
$sending_queue_1->newsletter_id = $this->post_notification->id;
$sending_queue_1->scheduled_at = Scheduler::getPreviousRunDate($schedule);
$sending_queue_1->status = SendingQueue::STATUS_SCHEDULED;
$sending_queue_1->save();
$sending_queue_2 = SendingTask::create();
$sending_queue_2->newsletter_id = $this->post_notification->id;
$sending_queue_2->scheduled_at = $random_future_date;
$sending_queue_2->status = SendingQueue::STATUS_SCHEDULED;
$sending_queue_2->save();
$sending_queue_3 = SendingTask::create();
$sending_queue_3->newsletter_id = $this->post_notification->id;
$sending_queue_3->scheduled_at = Scheduler::getPreviousRunDate($schedule);
$sending_queue_3->save();
$sendingQueue1 = SendingTask::create();
$sendingQueue1->newsletterId = $this->postNotification->id;
$sendingQueue1->scheduledAt = Scheduler::getPreviousRunDate($schedule);
$sendingQueue1->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue1->save();
$sendingQueue2 = SendingTask::create();
$sendingQueue2->newsletterId = $this->postNotification->id;
$sendingQueue2->scheduledAt = $randomFutureDate;
$sendingQueue2->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue2->save();
$sendingQueue3 = SendingTask::create();
$sendingQueue3->newsletterId = $this->postNotification->id;
$sendingQueue3->scheduledAt = Scheduler::getPreviousRunDate($schedule);
$sendingQueue3->save();
$this->endpoint->setStatus(
[
'id' => $this->post_notification->id,
'id' => $this->postNotification->id,
'status' => Newsletter::STATUS_ACTIVE,
]
);
@@ -533,28 +533,28 @@ class NewslettersTest extends \MailPoetTest {
// previously scheduled notification is rescheduled for future date
expect($tasks[0]->scheduled_at)->equals(Scheduler::getNextRunDate($schedule));
// future scheduled notifications are left intact
expect($tasks[1]->scheduled_at)->equals($random_future_date);
expect($tasks[1]->scheduled_at)->equals($randomFutureDate);
// previously unscheduled (e.g., sent/sending) notifications are left intact
expect($tasks[2]->scheduled_at)->equals(Scheduler::getPreviousRunDate($schedule));
}
public function testItSchedulesPostNotificationsWhenStatusIsSetBackToActive() {
$newsletter_option_field = NewsletterOptionField::create();
$newsletter_option_field->name = 'schedule';
$newsletter_option_field->newsletter_type = Newsletter::TYPE_NOTIFICATION;
$newsletter_option_field->save();
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = 'schedule';
$newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
$newsletterOptionField->save();
$schedule = '* * * * *';
NewsletterOption::createOrUpdate(
[
'newsletter_id' => $this->post_notification->id,
'option_field_id' => $newsletter_option_field->id,
'newsletter_id' => $this->postNotification->id,
'option_field_id' => $newsletterOptionField->id,
'value' => $schedule,
]
);
$this->endpoint->setStatus(
[
'id' => $this->post_notification->id,
'id' => $this->postNotification->id,
'status' => Newsletter::STATUS_ACTIVE,
]
);
@@ -565,8 +565,8 @@ class NewslettersTest extends \MailPoetTest {
public function testItCanRestoreANewsletter() {
$this->newsletter->trash();
$trashed_newsletter = Newsletter::findOne($this->newsletter->id);
expect($trashed_newsletter->deleted_at)->notNull();
$trashedNewsletter = Newsletter::findOne($this->newsletter->id);
expect($trashedNewsletter->deletedAt)->notNull();
$response = $this->endpoint->restore(['id' => $this->newsletter->id]);
expect($response->status)->equals(APIResponse::STATUS_OK);
@@ -606,7 +606,7 @@ class NewslettersTest extends \MailPoetTest {
$wp,
$this->makeEmpty(WCHelper::class),
SettingsController::getInstance(),
$this->cron_helper,
$this->cronHelper,
$this->make(AuthorizedEmailsController::class, ['onNewsletterUpdate' => Expected::never()]),
ContainerWrapper::getInstance()->get(NewslettersRepository::class),
ContainerWrapper::getInstance()->get(NewslettersResponseBuilder::class),
@@ -626,11 +626,11 @@ class NewslettersTest extends \MailPoetTest {
);
expect($response->meta['count'])->equals(1);
$hook_name = 'mailpoet_api_newsletters_duplicate_after';
expect(WPHooksHelper::isActionDone($hook_name))->true();
expect(WPHooksHelper::getActionDone($hook_name)[0] instanceof Newsletter)->true();
$hookName = 'mailpoet_api_newsletters_duplicate_after';
expect(WPHooksHelper::isActionDone($hookName))->true();
expect(WPHooksHelper::getActionDone($hookName)[0] instanceof Newsletter)->true();
$response = $this->endpoint->duplicate(['id' => $this->post_notification->id]);
$response = $this->endpoint->duplicate(['id' => $this->postNotification->id]);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->data)->equals(
Newsletter::where('subject', 'Copy of My Post Notification')
@@ -659,35 +659,35 @@ class NewslettersTest extends \MailPoetTest {
}
public function testItCanGetListingData() {
$segment_1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$segment_2 = Segment::createOrUpdate(['name' => 'Segment 2']);
$segment1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$segment2 = Segment::createOrUpdate(['name' => 'Segment 2']);
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->hydrate(
$newsletterSegment = NewsletterSegment::create();
$newsletterSegment->hydrate(
[
'newsletter_id' => $this->newsletter->id,
'segment_id' => $segment_1->id,
'segment_id' => $segment1->id,
]
);
$newsletter_segment->save();
$newsletterSegment->save();
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->hydrate(
$newsletterSegment = NewsletterSegment::create();
$newsletterSegment->hydrate(
[
'newsletter_id' => $this->newsletter->id,
'segment_id' => $segment_2->id,
'segment_id' => $segment2->id,
]
);
$newsletter_segment->save();
$newsletterSegment->save();
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->hydrate(
$newsletterSegment = NewsletterSegment::create();
$newsletterSegment->hydrate(
[
'newsletter_id' => $this->post_notification->id,
'segment_id' => $segment_2->id,
'newsletter_id' => $this->postNotification->id,
'segment_id' => $segment2->id,
]
);
$newsletter_segment->save();
$newsletterSegment->save();
$response = $this->endpoint->listing();
@@ -704,55 +704,55 @@ class NewslettersTest extends \MailPoetTest {
// 1st subscriber has 2 segments
expect($response->data[0]['segments'])->count(2);
expect($response->data[0]['segments'][0]['id'])
->equals($segment_1->id);
->equals($segment1->id);
expect($response->data[0]['segments'][1]['id'])
->equals($segment_2->id);
->equals($segment2->id);
// 2nd subscriber has 1 segment
expect($response->data[1]['segments'])->count(1);
expect($response->data[1]['segments'][0]['id'])
->equals($segment_2->id);
->equals($segment2->id);
}
public function testItCanFilterListing() {
// create 2 segments
$segment_1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$segment_2 = Segment::createOrUpdate(['name' => 'Segment 2']);
$segment1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$segment2 = Segment::createOrUpdate(['name' => 'Segment 2']);
// link standard newsletter to the 2 segments
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->hydrate(
$newsletterSegment = NewsletterSegment::create();
$newsletterSegment->hydrate(
[
'newsletter_id' => $this->newsletter->id,
'segment_id' => $segment_1->id,
'segment_id' => $segment1->id,
]
);
$newsletter_segment->save();
$newsletterSegment->save();
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->hydrate
$newsletterSegment = NewsletterSegment::create();
$newsletterSegment->hydrate
([
'newsletter_id' => $this->newsletter->id,
'segment_id' => $segment_2->id,
'segment_id' => $segment2->id,
]
);
$newsletter_segment->save();
$newsletterSegment->save();
// link post notification to the 2nd segment
$newsletter_segment = NewsletterSegment::create();
$newsletter_segment->hydrate(
$newsletterSegment = NewsletterSegment::create();
$newsletterSegment->hydrate(
[
'newsletter_id' => $this->post_notification->id,
'segment_id' => $segment_2->id,
'newsletter_id' => $this->postNotification->id,
'segment_id' => $segment2->id,
]
);
$newsletter_segment->save();
$newsletterSegment->save();
// filter by 1st segment
$response = $this->endpoint->listing(
[
'filter' => [
'segment' => $segment_1->id,
'segment' => $segment1->id,
],
]
);
@@ -767,7 +767,7 @@ class NewslettersTest extends \MailPoetTest {
$response = $this->endpoint->listing(
[
'filter' => [
'segment' => $segment_2->id,
'segment' => $segment2->id,
],
]
);
@@ -793,7 +793,7 @@ class NewslettersTest extends \MailPoetTest {
expect($response->meta['count'])->equals(2);
expect($response->data)->count(1);
expect($response->data[0]['subject'])->equals(
$this->post_notification->subject
$this->postNotification->subject
);
// get 1st page (limit items per page to 1)
@@ -814,22 +814,22 @@ class NewslettersTest extends \MailPoetTest {
}
public function testItCanBulkDeleteSelectionOfNewsletters() {
$selection_ids = [
$selectionIds = [
$this->newsletter->id,
$this->post_notification->id,
$this->postNotification->id,
];
$response = $this->endpoint->bulkAction(
[
'listing' => [
'selection' => $selection_ids,
'selection' => $selectionIds,
],
'action' => 'delete',
]
);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($response->meta['count'])->equals(count($selection_ids));
expect($response->meta['count'])->equals(count($selectionIds));
}
public function testItCanBulkDeleteNewsletters() {
@@ -870,17 +870,17 @@ class NewslettersTest extends \MailPoetTest {
'mailer' => $this->makeEmpty(
Mailer::class,
[
'send' => function ($newsletter, $subscriber, $extra_params) {
$unsubscribeLink = $this->subscription_url_factory->getUnsubscribeUrl(null);
$manageLink = $this->subscription_url_factory->getManageUrl(null);
'send' => function ($newsletter, $subscriber, $extraParams) {
$unsubscribeLink = $this->subscriptionUrlFactory->getUnsubscribeUrl(null);
$manageLink = $this->subscriptionUrlFactory->getManageUrl(null);
$viewInBrowserLink = Url::getViewInBrowserUrl(null, $this->newsletter, false, false, true);
$mailerMetaInfo = new MetaInfo;
expect(is_array($newsletter))->true();
expect($newsletter['body']['text'])->contains('Hello test');
expect($subscriber)->equals($subscriber);
expect($extra_params['unsubscribe_url'])->equals(home_url());
expect($extra_params['meta'])->equals($mailerMetaInfo->getPreviewMetaInfo());
expect($extraParams['unsubscribe_url'])->equals(home_url());
expect($extraParams['meta'])->equals($mailerMetaInfo->getPreviewMetaInfo());
// system links are replaced with hashes
expect($newsletter['body']['html'])->contains('href="' . $viewInBrowserLink . '">View in browser');
expect($newsletter['body']['html'])->contains('href="' . $unsubscribeLink . '">Unsubscribe');
@@ -955,7 +955,7 @@ class NewslettersTest extends \MailPoetTest {
$wp,
$this->makeEmpty(WCHelper::class),
SettingsController::getInstance(),
$this->cron_helper,
$this->cronHelper,
ContainerWrapper::getInstance()->get(AuthorizedEmailsController::class),
ContainerWrapper::getInstance()->get(NewslettersRepository::class),
ContainerWrapper::getInstance()->get(NewslettersResponseBuilder::class),
@@ -973,13 +973,13 @@ class NewslettersTest extends \MailPoetTest {
public function testItGeneratesPreviewLinksWithNewsletterHashAndNoSubscriberData() {
$response = $this->endpoint->listing();
$preview_link = $response->data[0]['preview_url'];
parse_str((string)parse_url($preview_link, PHP_URL_QUERY), $preview_link_data);
$preview_link_data = Url::transformUrlDataObject(Router::decodeRequestData($preview_link_data['data']));
expect($preview_link_data['newsletter_hash'])->notEmpty();
expect($preview_link_data['subscriber_id'])->false();
expect($preview_link_data['subscriber_token'])->false();
expect((boolean)$preview_link_data['preview'])->true();
$previewLink = $response->data[0]['preview_url'];
parse_str((string)parse_url($previewLink, PHP_URL_QUERY), $previewLinkData);
$previewLinkData = Url::transformUrlDataObject(Router::decodeRequestData($previewLinkData['data']));
expect($previewLinkData['newsletter_hash'])->notEmpty();
expect($previewLinkData['subscriber_id'])->false();
expect($previewLinkData['subscriber_token'])->false();
expect((boolean)$previewLinkData['preview'])->true();
}
public function testItDeletesSendingQueueAndSetsNewsletterStatusToDraftWhenItIsUnscheduled() {
@@ -988,33 +988,33 @@ class NewslettersTest extends \MailPoetTest {
$newsletter->save();
expect($newsletter->getErrors())->false();
$sending_queue = SendingTask::create();
$sending_queue->newsletter_id = $newsletter->id;
$sending_queue->newsletter_rendered_body = [
$sendingQueue = SendingTask::create();
$sendingQueue->newsletterId = $newsletter->id;
$sendingQueue->newsletterRenderedBody = [
'html' => 'html',
'text' => 'text',
];
$sending_queue->status = SendingQueue::STATUS_SCHEDULED;
$sending_queue->scheduled_at = Carbon::now()->format('Y-m-d H:i');
$sending_queue->save();
expect($sending_queue->getErrors())->false();
$sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue->scheduledAt = Carbon::now()->format('Y-m-d H:i');
$sendingQueue->save();
expect($sendingQueue->getErrors())->false();
$newsletter_data = [
$newsletterData = [
'id' => $newsletter->id,
'options' => [
'isScheduled' => false,
],
];
$this->endpoint->save($newsletter_data);
$this->endpoint->save($newsletterData);
$newsletter = Newsletter::findOne($newsletter->id);
$sending_queue = SendingQueue::findOne($sending_queue->id);
$sendingQueue = SendingQueue::findOne($sendingQueue->id);
expect($newsletter->status)->equals(Newsletter::STATUS_DRAFT);
expect($sending_queue)->false();
expect($sendingQueue)->false();
}
public function testItSavesDefaultSenderIfNeeded() {
$settings = $this->di_container->get(SettingsController::class);
$settings = $this->diContainer->get(SettingsController::class);
$settings->set('sender', null);
$data = [
@@ -1030,7 +1030,7 @@ class NewslettersTest extends \MailPoetTest {
}
public function testItDoesntSaveDefaultSenderWhenEmptyValues() {
$settings = $this->di_container->get(SettingsController::class);
$settings = $this->diContainer->get(SettingsController::class);
$settings->set('sender', null);
$data = [
@@ -1045,7 +1045,7 @@ class NewslettersTest extends \MailPoetTest {
}
public function testItDoesntOverrideDefaultSender() {
$settings = $this->di_container->get(SettingsController::class);
$settings = $this->diContainer->get(SettingsController::class);
$settings->set('sender', [
'name' => 'Test sender',
'address' => 'test@example.com',