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

Move API save tests to controller tests

Browse Source 
[MAILPOET-2900]
This commit is contained in:
Jan Jakeš
2020-05-13 16:26:37 +02:00
committed by Veljko V
parent f986da4d7f
commit 770cda5c3c
2 changed files with 339 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -31,7 +31,6 @@ use MailPoet\Newsletter\Scheduler\Scheduler;
use MailPoet\Newsletter\Statistics\NewsletterStatisticsRepository;
use MailPoet\Newsletter\Url;
use MailPoet\Router\Router;
use MailPoet\Services\AuthorizedEmailsController;
use MailPoet\Settings\SettingsController;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Util\License\Features\Subscribers as SubscribersFeature;
@ -168,253 +167,18 @@ class NewslettersTest extends \MailPoetTest {
expect(WPHooksHelper::getFilterApplied($hookName)[0])->internalType('array');
}
public function testItCanSaveANewNewsletter() {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = 'some_option';
$newsletterOptionField->newsletterType = Newsletter::TYPE_STANDARD;
$newsletterOptionField->save();
$validData = [
'subject' => 'My First Newsletter',
'type' => Newsletter::TYPE_STANDARD,
'options' => [
$newsletterOptionField->name => 'some_option_value',
],
'body' => 'some text',
];
$emoji = $this->make(
Emoji::class,
['encodeForUTF8Column' => Expected::once(function ($params) {
return $params;
})]
);
$wp = Stub::make(new WPFunctions, [
'applyFilters' => asCallable([WPHooksHelper::class, 'applyFilters']),
'doAction' => asCallable([WPHooksHelper::class, 'doAction']),
]);
$this->endpoint = $this->createNewslettersEndpointWithMocks([
'wp' => $wp,
'cronHelper' => $this->cronHelper,
'authorizedEmailsController' => $this->make(AuthorizedEmailsController::class, ['onNewsletterSenderAddressUpdate' => Expected::once()]),
'emoji' => $emoji,
'subscribersFeature' => Stub::make(SubscribersFeature::class),
]);
$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($savedNewsletter->asArray());
// newsletter option should be saved
expect($savedNewsletter->someOption)->equals('some_option_value');
expect(strlen($savedNewsletter->unsubscribeToken))->equals(15);
$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();
$invalidData = [
'subject' => 'Missing newsletter type',
];
$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() {
public function testItCanSaveANewsletter() {
$newsletterData = [
'id' => $this->newsletter->id,
'subject' => 'My Updated Newsletter',
];
$response = $this->endpoint->save($newsletterData);
$updatedNewsletter = Newsletter::findOne($this->newsletter->id);
expect($response->status)->equals(APIResponse::STATUS_OK);
$updatedNewsletter = Newsletter::findOne($this->newsletter->id);
expect($response->data)->equals($updatedNewsletter->asArray());
expect($updatedNewsletter->subject)->equals('My Updated Newsletter');
}
public function testItDoesNotRerenderPostNotificationsUponUpdate() {
$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();
$newsletterData = [
'id' => $this->postNotification->id,
'subject' => 'My Updated Newsletter',
'body' => Fixtures::get('newsletter_body_template'),
];
$response = $this->endpoint->save($newsletterData);
$updatedQueue = SendingQueue::where('newsletter_id', $this->postNotification->id)
->findOne()
->asArray();
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($updatedQueue['newsletter_rendered_body'])->null();
expect($updatedQueue['newsletter_rendered_subject'])->null();
}
public function testItCanRerenderQueueUponSave() {
$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();
$newsletterData = [
'id' => $this->newsletter->id,
'subject' => 'My Updated Newsletter',
'body' => Fixtures::get('newsletter_body_template'),
];
$response = $this->endpoint->save($newsletterData);
$updatedQueue = SendingQueue::where('newsletter_id', $this->newsletter->id)
->findOne()
->asArray();
expect($response->status)->equals(APIResponse::STATUS_OK);
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() {
$newsletterOptions = [
'intervalType',
'timeOfDay',
'weekDay',
'monthDay',
'nthWeekDay',
'schedule',
];
foreach ($newsletterOptions as $option) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $option;
$newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
$newsletterOptionField->save();
}
$newsletterData = [
'id' => $this->newsletter->id,
'type' => Newsletter::TYPE_NOTIFICATION,
'subject' => 'Newsletter',
'options' => [
'intervalType' => PostNotificationScheduler::INTERVAL_WEEKLY,
'timeOfDay' => '50400',
'weekDay' => '1',
'monthDay' => '0',
'nthWeekDay' => '1',
'schedule' => '0 14 * * 1',
],
];
$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($savedNewsletter->asArray());
// schedule should be recalculated when options change
$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($savedNewsletter->schedule)->equals('* * * * *');
}
public function testItCanReschedulePreviouslyScheduledSendingQueueJobs() {
// create newsletter options
$newsletterOptions = [
'intervalType',
'timeOfDay',
'weekDay',
'monthDay',
'nthWeekDay',
'schedule',
];
foreach ($newsletterOptions as $option) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $option;
$newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
$newsletterOptionField->save();
}
// create sending queues
$currentTime = Carbon::now();
$sendingQueue1 = SendingTask::create();
$sendingQueue1->newsletterId = 1;
$sendingQueue1->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue1->scheduledAt = $currentTime;
$sendingQueue1->save();
$sendingQueue2 = SendingTask::create();
$sendingQueue2->newsletterId = 1;
$sendingQueue2->save();
// save newsletter via router
$newsletterData = [
'id' => 1,
'type' => Newsletter::TYPE_NOTIFICATION,
'subject' => 'Newsletter',
'options' => [
// weekly on Monday @ 7am
'intervalType' => PostNotificationScheduler::INTERVAL_WEEKLY,
'timeOfDay' => '25200',
'weekDay' => '1',
'monthDay' => '0',
'nthWeekDay' => '1',
'schedule' => '0 7 * * 1',
],
];
$newsletter = $this->endpoint->save($newsletterData);
/** @var SendingQueue $sendingQueue1 */
$sendingQueue1 = SendingQueue::findOne($sendingQueue1->id);
$sendingQueue1 = SendingTask::createFromQueue($sendingQueue1);
/** @var SendingQueue $sendingQueue2 */
$sendingQueue2 = SendingQueue::findOne($sendingQueue2->id);
$sendingQueue2 = SendingTask::createFromQueue($sendingQueue2);
expect($sendingQueue1->scheduledAt)->notEquals($currentTime);
expect($sendingQueue1->scheduledAt)->equals(
Scheduler::getNextRunDate($newsletter->data['schedule'])
);
expect($sendingQueue2->scheduledAt)->null();
}
public function testItCanModifySegmentsOfExistingNewsletter() {
$segment1 = Segment::createOrUpdate(['name' => 'Segment 1']);
$fakeSegmentId = 1;
$newsletterData = [
'id' => $this->newsletter->id,
'subject' => 'My Updated Newsletter',
'segments' => [
$segment1->asArray(),
$fakeSegmentId,
],
];
$response = $this->endpoint->save($newsletterData);
expect($response->status)->equals(APIResponse::STATUS_OK);
$updatedNewsletter =
Newsletter::findOne($this->newsletter->id)
->withSegments();
expect(count($updatedNewsletter->segments))->equals(1);
expect($updatedNewsletter->segments[0]['name'])->equals('Segment 1');
}
public function testItReturnsErrorIfSubscribersLimitReached() {
@ -901,87 +665,6 @@ class NewslettersTest extends \MailPoetTest {
expect((boolean)$previewLinkData['preview'])->true();
}
public function testItDeletesSendingQueueAndSetsNewsletterStatusToDraftWhenItIsUnscheduled() {
$newsletter = $this->newsletter;
$newsletter->status = Newsletter::STATUS_SCHEDULED;
$newsletter->save();
expect($newsletter->getErrors())->false();
$sendingQueue = SendingTask::create();
$sendingQueue->newsletterId = $newsletter->id;
$sendingQueue->newsletterRenderedBody = [
'html' => 'html',
'text' => 'text',
];
$sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
$sendingQueue->scheduledAt = Carbon::now()->format('Y-m-d H:i');
$sendingQueue->save();
expect($sendingQueue->getErrors())->false();
$newsletterData = [
'id' => $newsletter->id,
'options' => [
'isScheduled' => false,
],
];
$this->endpoint->save($newsletterData);
$newsletter = Newsletter::findOne($newsletter->id);
$sendingQueue = SendingQueue::findOne($sendingQueue->id);
expect($newsletter->status)->equals(Newsletter::STATUS_DRAFT);
expect($sendingQueue)->false();
}
public function testItSavesDefaultSenderIfNeeded() {
$settings = $this->diContainer->get(SettingsController::class);
$settings->set('sender', null);
$data = [
'subject' => 'My New Newsletter',
'type' => Newsletter::TYPE_STANDARD,
'sender_name' => 'Test sender',
'sender_address' => 'test@example.com',
];
$response = $this->endpoint->save($data);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($settings->get('sender.name'))->same('Test sender');
expect($settings->get('sender.address'))->same('test@example.com');
}
public function testItDoesntSaveDefaultSenderWhenEmptyValues() {
$settings = $this->diContainer->get(SettingsController::class);
$settings->set('sender', null);
$data = [
'subject' => 'My New Newsletter',
'type' => Newsletter::TYPE_STANDARD,
'sender_name' => '',
'sender_address' => null,
];
$response = $this->endpoint->save($data);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($settings->get('sender'))->null();
}
public function testItDoesntOverrideDefaultSender() {
$settings = $this->diContainer->get(SettingsController::class);
$settings->set('sender', [
'name' => 'Test sender',
'address' => 'test@example.com',
]);
$data = [
'subject' => 'My New Newsletter',
'type' => Newsletter::TYPE_STANDARD,
'sender_name' => 'Another test sender',
'sender_address' => 'another.test@example.com',
];
$response = $this->endpoint->save($data);
expect($response->status)->equals(APIResponse::STATUS_OK);
expect($settings->get('sender.name'))->same('Test sender');
expect($settings->get('sender.address'))->same('test@example.com');
}
public function _after() {
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterSegment::$_table);