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

Refactor Newsletter::preProcessNewsletter() to use Doctrine

Browse Source 
This commit also removes almost all the usages of the old Newsletter
model from NewsletterTest.

[MAILPOET-4680]
This commit is contained in:
Rodrigo Primo
2022-09-23 16:21:10 -03:00
committed by Aschepikov
parent 095cddc67e
commit d39440f1dc
4 changed files with 89 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
mailpoet/lib/Cron/Workers/SendingQueue/SendingQueue.php
View File

@ -159,14 +159,9 @@ class SendingQueue {
return; return;
} }
$newsletter = Newsletter::findOne($newsletterEntity->getId());
if (!$newsletter) {
return;
}
// pre-process newsletter (render, replace shortcodes/links, etc.) // pre-process newsletter (render, replace shortcodes/links, etc.)
$newsletter = $this->newsletterTask->preProcessNewsletter($newsletter, $queue); $newsletterEntity = $this->newsletterTask->preProcessNewsletter($newsletterEntity, $queue);
if (!$newsletter) { if (!$newsletterEntity) {
$this->loggerFactory->getLogger(LoggerFactory::TOPIC_NEWSLETTERS)->info( $this->loggerFactory->getLogger(LoggerFactory::TOPIC_NEWSLETTERS)->info(
'delete task in sending queue', 'delete task in sending queue',
['task_id' => $queue->taskId] ['task_id' => $queue->taskId]
@ -174,6 +169,12 @@ class SendingQueue {
$queue->delete(); $queue->delete();
return; return;
} }
$newsletter = Newsletter::findOne($newsletterEntity->getId());
if (!$newsletter) {
return;
}
// clone the original object to be used for processing // clone the original object to be used for processing
$_newsletter = (object)$newsletter->asArray(); $_newsletter = (object)$newsletter->asArray();
$_newsletter->options = $newsletterEntity->getOptionsAsArray(); $_newsletter->options = $newsletterEntity->getOptionsAsArray();
@ -255,10 +256,8 @@ class SendingQueue {
'completed newsletter sending', 'completed newsletter sending',
['newsletter_id' => $newsletter->id, 'task_id' => $queue->taskId] ['newsletter_id' => $newsletter->id, 'task_id' => $queue->taskId]
); );
$newsletter = $this->newslettersRepository->findOneById($newsletter->id); $this->newsletterTask->markNewsletterAsSent($newsletterEntity, $queue);
assert($newsletter instanceof NewsletterEntity); $this->statsNotificationsScheduler->schedule($newsletterEntity);
$this->newsletterTask->markNewsletterAsSent($newsletter, $queue);
$this->statsNotificationsScheduler->schedule($newsletter);
} }
$this->enforceSendingAndExecutionLimits($timer); $this->enforceSendingAndExecutionLimits($timer);
} }

31
mailpoet/lib/Cron/Workers/SendingQueue/Tasks/Newsletter.php
View File

@ -114,7 +114,7 @@ class Newsletter {
return $newsletter; return $newsletter;
} }
public function preProcessNewsletter(\MailPoet\Models\Newsletter $newsletter, Sending $sendingTask) { public function preProcessNewsletter(NewsletterEntity $newsletter, Sending $sendingTask) {
// return the newsletter if it was previously rendered // return the newsletter if it was previously rendered
/** @phpstan-ignore-next-line - SendingQueue::getNewsletterRenderedBody() is called inside Sending using __call(). Sending will be refactored soon to stop using Paris models. */ /** @phpstan-ignore-next-line - SendingQueue::getNewsletterRenderedBody() is called inside Sending using __call(). Sending will be refactored soon to stop using Paris models. */
if (!is_null($sendingTask->getNewsletterRenderedBody())) { if (!is_null($sendingTask->getNewsletterRenderedBody())) {
@ -124,57 +124,56 @@ class Newsletter {
} }
$this->loggerFactory->getLogger(LoggerFactory::TOPIC_NEWSLETTERS)->info( $this->loggerFactory->getLogger(LoggerFactory::TOPIC_NEWSLETTERS)->info(
'pre-processing newsletter', 'pre-processing newsletter',
['newsletter_id' => $newsletter->id, 'task_id' => $sendingTask->taskId] ['newsletter_id' => $newsletter->getId(), 'task_id' => $sendingTask->taskId]
); );
$newsletterEntity = $this->newslettersRepository->findOneById($newsletter->id);
if (!$newsletterEntity) return false;
// if tracking is enabled, do additional processing // if tracking is enabled, do additional processing
if ($this->trackingEnabled) { if ($this->trackingEnabled) {
// hook to the newsletter post-processing filter and add tracking image // hook to the newsletter post-processing filter and add tracking image
$this->trackingImageInserted = OpenTracking::addTrackingImage(); $this->trackingImageInserted = OpenTracking::addTrackingImage();
// render newsletter // render newsletter
$renderedNewsletter = $this->renderer->render($newsletterEntity, $sendingTask); $renderedNewsletter = $this->renderer->render($newsletter, $sendingTask);
$renderedNewsletter = $this->wp->applyFilters( $renderedNewsletter = $this->wp->applyFilters(
'mailpoet_sending_newsletter_render_after', 'mailpoet_sending_newsletter_render_after',
$renderedNewsletter, $renderedNewsletter,
$newsletter $newsletter
); );
$renderedNewsletter = $this->gaTracking->applyGATracking($renderedNewsletter, $newsletterEntity); $renderedNewsletter = $this->gaTracking->applyGATracking($renderedNewsletter, $newsletter);
// hash and save all links // hash and save all links
$renderedNewsletter = $this->linksTask->process($renderedNewsletter, $newsletterEntity, $sendingTask); $renderedNewsletter = $this->linksTask->process($renderedNewsletter, $newsletter, $sendingTask);
} else { } else {
// render newsletter // render newsletter
$renderedNewsletter = $this->renderer->render($newsletterEntity, $sendingTask); $renderedNewsletter = $this->renderer->render($newsletter, $sendingTask);
$renderedNewsletter = $this->wp->applyFilters( $renderedNewsletter = $this->wp->applyFilters(
'mailpoet_sending_newsletter_render_after', 'mailpoet_sending_newsletter_render_after',
$renderedNewsletter, $renderedNewsletter,
$newsletter $newsletter
); );
$renderedNewsletter = $this->gaTracking->applyGATracking($renderedNewsletter, $newsletterEntity); $renderedNewsletter = $this->gaTracking->applyGATracking($renderedNewsletter, $newsletter);
} }
// check if this is a post notification and if it contains at least 1 ALC post // check if this is a post notification and if it contains at least 1 ALC post
if ( if (
$newsletter->type === NewsletterEntity::TYPE_NOTIFICATION_HISTORY && $newsletter->getType() === NewsletterEntity::TYPE_NOTIFICATION_HISTORY &&
$this->postsTask->getAlcPostsCount($renderedNewsletter, $newsletterEntity) === 0 $this->postsTask->getAlcPostsCount($renderedNewsletter, $newsletter) === 0
) { ) {
// delete notification history record since it will never be sent // delete notification history record since it will never be sent
$this->loggerFactory->getLogger(LoggerFactory::TOPIC_POST_NOTIFICATIONS)->info( $this->loggerFactory->getLogger(LoggerFactory::TOPIC_POST_NOTIFICATIONS)->info(
'no posts in post notification, deleting it', 'no posts in post notification, deleting it',
['newsletter_id' => $newsletter->id, 'task_id' => $sendingTask->taskId] ['newsletter_id' => $newsletter->getId(), 'task_id' => $sendingTask->taskId]
); );
$this->newslettersRepository->bulkDelete([(int)$newsletter->id]); $this->newslettersRepository->bulkDelete([(int)$newsletter->getId()]);
return false; return false;
} }
// extract and save newsletter posts // extract and save newsletter posts
$this->postsTask->extractAndSave($renderedNewsletter, $newsletterEntity); $this->postsTask->extractAndSave($renderedNewsletter, $newsletter);
$sendingQueueEntity = $sendingTask->getSendingQueueEntity(); $sendingQueueEntity = $sendingTask->getSendingQueueEntity();
// update queue with the rendered and pre-processed newsletter // update queue with the rendered and pre-processed newsletter
$sendingTask->newsletterRenderedSubject = ShortcodesTask::process( $sendingTask->newsletterRenderedSubject = ShortcodesTask::process(
$newsletter->subject, $newsletter->getSubject(),
$renderedNewsletter['html'], $renderedNewsletter['html'],
$newsletterEntity, $newsletter,
null, null,
$sendingQueueEntity $sendingQueueEntity
); );

2
mailpoet/lib/Newsletter/NewsletterSaveController.php
View File

@ -403,7 +403,7 @@ class NewsletterSaveController {
$queueModel->newsletterRenderedBody = null; $queueModel->newsletterRenderedBody = null;
$newsletterQueueTask = new NewsletterQueueTask(); $newsletterQueueTask = new NewsletterQueueTask();
$newsletterQueueTask->preProcessNewsletter($newsletterModel, $queueModel); $newsletterQueueTask->preProcessNewsletter($newsletter, $queueModel);
// 'preProcessNewsletter' modifies queue by old model - let's reload it // 'preProcessNewsletter' modifies queue by old model - let's reload it
$this->entityManager->refresh($queue); $this->entityManager->refresh($queue);

121
mailpoet/tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
View File

@ -13,7 +13,6 @@ use MailPoet\DI\ContainerWrapper;
use MailPoet\Entities\NewsletterEntity; use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterLinkEntity; use MailPoet\Entities\NewsletterLinkEntity;
use MailPoet\Entities\NewsletterPostEntity; use MailPoet\Entities\NewsletterPostEntity;
use MailPoet\Entities\NewsletterSegmentEntity;
use MailPoet\Entities\ScheduledTaskEntity; use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\SendingQueueEntity; use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity; use MailPoet\Entities\SubscriberEntity;
@ -27,10 +26,11 @@ use MailPoet\Router\Router;
use MailPoet\Settings\SettingsRepository; use MailPoet\Settings\SettingsRepository;
use MailPoet\Tasks\Sending; use MailPoet\Tasks\Sending;
use MailPoet\Tasks\Sending as SendingTask; use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\Segment as SegmentFactory; use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory; use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory;
use MailPoet\WP\Emoji; use MailPoet\WP\Emoji;
use MailPoet\WP\Functions as WPFunctions; use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon;
class NewsletterTest extends \MailPoetTest { class NewsletterTest extends \MailPoetTest {
/** @var NewsletterTask */ /** @var NewsletterTask */
@ -39,10 +39,10 @@ class NewsletterTest extends \MailPoetTest {
/** @var SubscriberEntity */ /** @var SubscriberEntity */
private $subscriber; private $subscriber;
/** @var Newsletter */ /** @var NewsletterEntity */
private $newsletter; private $newsletter;
/** @var Newsletter */ /** @var NewsletterEntity */
private $parentNewsletter; private $parentNewsletter;
/** @var SendingTask */ /** @var SendingTask */
@ -64,21 +64,21 @@ class NewsletterTest extends \MailPoetTest {
parent::_before(); parent::_before();
$this->newsletterTask = new NewsletterTask(); $this->newsletterTask = new NewsletterTask();
$this->subscriber = (new SubscriberFactory())->create(); $this->subscriber = (new SubscriberFactory())->create();
$this->newsletter = Newsletter::create(); $this->newsletter = (new NewsletterFactory())
$this->newsletter->type = NewsletterEntity::TYPE_STANDARD; ->withType(NewsletterEntity::TYPE_STANDARD)
$this->newsletter->status = NewsletterEntity::STATUS_ACTIVE; ->withStatus(NewsletterEntity::STATUS_ACTIVE)
$this->newsletter->subject = Fixtures::get('newsletter_subject_template'); ->withSubject(Fixtures::get('newsletter_subject_template'))
$this->newsletter->body = Fixtures::get('newsletter_body_template'); ->withBody(json_decode(Fixtures::get('newsletter_body_template'), true))
$this->newsletter->preheader = ''; ->create();
$this->newsletter->save();
$this->parentNewsletter = Newsletter::create(); $this->parentNewsletter = (new NewsletterFactory())
$this->parentNewsletter->type = NewsletterEntity::TYPE_STANDARD; ->withType(NewsletterEntity::TYPE_STANDARD)
$this->parentNewsletter->status = NewsletterEntity::STATUS_ACTIVE; ->withStatus(NewsletterEntity::STATUS_ACTIVE)
$this->parentNewsletter->subject = 'parent newsletter'; ->withSubject('parent newsletter')
$this->parentNewsletter->preheader = ''; ->create();
$this->parentNewsletter->save();
$this->sendingTask = SendingTask::create(); $this->sendingTask = SendingTask::create();
$this->sendingTask->newsletter_id = $this->newsletter->id; $this->sendingTask->newsletter_id = $this->newsletter->getId();
$this->sendingTask->save(); $this->sendingTask->save();
$this->loggerFactory = LoggerFactory::getInstance(); $this->loggerFactory = LoggerFactory::getInstance();
$this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class); $this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
@ -92,7 +92,7 @@ class NewsletterTest extends \MailPoetTest {
public function testItDoesNotGetNewsletterWhenStatusIsNotActiveOrSending() { public function testItDoesNotGetNewsletterWhenStatusIsNotActiveOrSending() {
// draft or any other status return false // draft or any other status return false
$newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id); $newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterEntity->setStatus(NewsletterEntity::STATUS_DRAFT); $newsletterEntity->setStatus(NewsletterEntity::STATUS_DRAFT);
$this->newslettersRepository->persist($newsletterEntity); $this->newslettersRepository->persist($newsletterEntity);
@ -112,20 +112,20 @@ class NewsletterTest extends \MailPoetTest {
} }
public function testItDoesNotGetDeletedNewsletter() { public function testItDoesNotGetDeletedNewsletter() {
$newsletter = $this->newsletter; $this->newsletter->setDeletedAt(new Carbon());
$newsletter->set_expr('deleted_at', 'NOW()'); $this->newslettersRepository->persist($this->newsletter);
$newsletter->save(); $this->newslettersRepository->flush();
expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->null(); expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->null();
} }
public function testItDoesNotGetNewsletterWhenParentNewsletterStatusIsNotActiveOrSending() { public function testItDoesNotGetNewsletterWhenParentNewsletterStatusIsNotActiveOrSending() {
// draft or any other status return false // draft or any other status return false
$parentNewsletterEntity = $this->newslettersRepository->findOneById($this->parentNewsletter->id); $parentNewsletterEntity = $this->newslettersRepository->findOneById($this->parentNewsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $parentNewsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $parentNewsletterEntity);
$parentNewsletterEntity->setStatus( NewsletterEntity::STATUS_DRAFT); $parentNewsletterEntity->setStatus( NewsletterEntity::STATUS_DRAFT);
$this->newslettersRepository->persist($parentNewsletterEntity); $this->newslettersRepository->persist($parentNewsletterEntity);
$this->newslettersRepository->flush(); $this->newslettersRepository->flush();
$newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id); $newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterEntity->setType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY); $newsletterEntity->setType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY);
$newsletterEntity->setParent($parentNewsletterEntity); $newsletterEntity->setParent($parentNewsletterEntity);
@ -146,20 +146,21 @@ class NewsletterTest extends \MailPoetTest {
} }
public function testItDoesNotGetDeletedNewsletterWhenParentNewsletterIsDeleted() { public function testItDoesNotGetDeletedNewsletterWhenParentNewsletterIsDeleted() {
$parentNewsletter = $this->parentNewsletter; $this->parentNewsletter->setDeletedAt(new Carbon());
$parentNewsletter->set_expr('deleted_at', 'NOW()'); $this->newslettersRepository->persist($this->parentNewsletter);
$parentNewsletter->save(); $this->newslettersRepository->flush();
$newsletter = $this->newsletter; $newsletter = $this->newsletter;
$newsletter->type = NewsletterEntity::TYPE_NOTIFICATION_HISTORY; $newsletter->setType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY);
$newsletter->parentId = $parentNewsletter->id; $newsletter->setParent($this->parentNewsletter);
$newsletter->save(); $this->newslettersRepository->persist($newsletter);
$this->newslettersRepository->flush();
expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->null(); expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->null();
} }
public function testItReturnsNewsletterObjectWhenRenderedNewsletterBodyExistsInTheQueue() { public function testItReturnsNewsletterObjectWhenRenderedNewsletterBodyExistsInTheQueue() {
$this->sendingTask->newsletterRenderedBody = ['html' => 'test', 'text' => 'test']; $this->sendingTask->newsletterRenderedBody = ['html' => 'test', 'text' => 'test'];
$result = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $result = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
expect($result instanceof \MailPoet\Models\Newsletter)->true(); expect($result instanceof NewsletterEntity)->true();
} }
public function testItHashesLinksAndInsertsTrackingImageWhenTrackingIsEnabled() { public function testItHashesLinksAndInsertsTrackingImageWhenTrackingIsEnabled() {
@ -169,9 +170,9 @@ class NewsletterTest extends \MailPoetTest {
$newsletterTask = new NewsletterTask($wp); $newsletterTask = new NewsletterTask($wp);
$newsletterTask->trackingEnabled = true; $newsletterTask->trackingEnabled = true;
$newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$link = $this->newsletterLinkRepository->findOneBy(['newsletter' => $this->newsletter->id]); $link = $this->newsletterLinkRepository->findOneBy(['newsletter' => $this->newsletter->getId()]);
$this->assertInstanceOf(NewsletterLinkEntity::class, $link); $this->assertInstanceOf(NewsletterLinkEntity::class, $link);
$updatedQueue = SendingTask::getByNewsletterId($this->newsletter->id); $updatedQueue = SendingTask::getByNewsletterId($this->newsletter->getId());
$renderedNewsletter = $updatedQueue->getNewsletterRenderedBody(); $renderedNewsletter = $updatedQueue->getNewsletterRenderedBody();
expect($renderedNewsletter['html']) expect($renderedNewsletter['html'])
->stringContainsString('[mailpoet_click_data]-' . $link->getHash()); ->stringContainsString('[mailpoet_click_data]-' . $link->getHash());
@ -191,9 +192,9 @@ class NewsletterTest extends \MailPoetTest {
$newsletterTask = new NewsletterTask($wp); $newsletterTask = new NewsletterTask($wp);
$newsletterTask->trackingEnabled = false; $newsletterTask->trackingEnabled = false;
$newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$link = $this->newsletterLinkRepository->findOneBy(['newsletter' => $this->newsletter->id]); $link = $this->newsletterLinkRepository->findOneBy(['newsletter' => $this->newsletter->getId()]);
expect($link)->null(); expect($link)->null();
$updatedQueue = SendingTask::getByNewsletterId($this->newsletter->id); $updatedQueue = SendingTask::getByNewsletterId($this->newsletter->getId());
$renderedNewsletter = $updatedQueue->getNewsletterRenderedBody(); $renderedNewsletter = $updatedQueue->getNewsletterRenderedBody();
expect($renderedNewsletter['html']) expect($renderedNewsletter['html'])
->stringNotContainsString('[mailpoet_click_data]'); ->stringNotContainsString('[mailpoet_click_data]');
@ -207,42 +208,44 @@ class NewsletterTest extends \MailPoetTest {
} }
public function testItReturnsFalseAndDeletesNewsletterWhenPostNotificationContainsNoPosts() { public function testItReturnsFalseAndDeletesNewsletterWhenPostNotificationContainsNoPosts() {
$newsletter = $this->newsletter; $this->newsletter->setType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY);
$this->newsletter->setParent($this->newsletter);
$newsletter->type = NewsletterEntity::TYPE_NOTIFICATION_HISTORY;
$newsletter->parentId = $newsletter->id;
// replace post id data tag with something else // replace post id data tag with something else
$newsletter->body = str_replace('data-post-id', 'id', $newsletter->getBodyString()); $body = $this->newsletter->getBody();
$newsletter->save(); $body['content'] = json_decode(str_replace('data-post-id', 'id', $this->newsletter->getContent()), true);
$this->newsletter->setBody($body);
$this->newslettersRepository->persist($this->newsletter);
$this->newslettersRepository->flush();
// returned result is false // returned result is false
$result = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $result = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
expect($result)->false(); expect($result)->false();
// newsletter is deleted. // newsletter is deleted.
$this->entityManager->clear(); // needed while part of the code uses Paris models and part uses Doctrine $this->entityManager->clear(); // needed while part of the code uses Paris models and part uses Doctrine
$newsletter = $this->newslettersRepository->findOneById($newsletter->id); $newsletter = $this->newslettersRepository->findOneById($this->newsletter->getId());
expect($newsletter)->null(); expect($newsletter)->null();
} }
public function testItSavesNewsletterPosts() { public function testItSavesNewsletterPosts() {
$newsletterPostRepository = ContainerWrapper::getInstance()->get(NewsletterPostsRepository::class); $newsletterPostRepository = ContainerWrapper::getInstance()->get(NewsletterPostsRepository::class);
$this->newsletter->type = NewsletterEntity::TYPE_NOTIFICATION_HISTORY; $this->newsletter->setType(NewsletterEntity::TYPE_NOTIFICATION_HISTORY);
$this->newsletter->parentId = $this->newsletter->id; $this->newsletter->setParent($this->newsletter);
$this->newslettersRepository->persist($this->newsletter);
$this->newslettersRepository->flush();
$postsTask = $this->make(PostsTask::class, [ $postsTask = $this->make(PostsTask::class, [
'getAlcPostsCount' => 1, 'getAlcPostsCount' => 1,
'loggerFactory' => $this->loggerFactory, 'loggerFactory' => $this->loggerFactory,
'newsletterPostRepository' => $newsletterPostRepository, 'newsletterPostRepository' => $newsletterPostRepository,
]); ]);
$this->newsletter->save();
$newsletterTask = new NewsletterTask(new WPFunctions, $postsTask); $newsletterTask = new NewsletterTask(new WPFunctions, $postsTask);
$result = $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $result = $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$newsletterPost = $newsletterPostRepository->findOneBy(['newsletter' => $this->newsletter->id]); $newsletterPost = $newsletterPostRepository->findOneBy(['newsletter' => $this->newsletter->getId()]);
expect($newsletterPost)->isInstanceOf(NewsletterPostEntity::class); expect($newsletterPost)->isInstanceOf(NewsletterPostEntity::class);
expect($result)->notEquals(false); expect($result)->notEquals(false);
expect($newsletterPost->getPostId())->equals('10'); expect($newsletterPost->getPostId())->equals('10');
} }
public function testItUpdatesStatusAndSetsSentAtDateOnlyForStandardAndPostNotificationNewsletters() { public function testItUpdatesStatusAndSetsSentAtDateOnlyForStandardAndPostNotificationNewsletters() {
$newsletter = $this->newslettersRepository->findOneById($this->newsletter->id); $newsletter = $this->newslettersRepository->findOneById($this->newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletter); $this->assertInstanceOf(NewsletterEntity::class, $newsletter);
$sendingQueue = $this->sendingTask->queue(); $sendingQueue = $this->sendingTask->queue();
$sendingQueue->processedAt = date('Y-m-d H:i:s'); $sendingQueue->processedAt = date('Y-m-d H:i:s');
@ -285,26 +288,28 @@ class NewsletterTest extends \MailPoetTest {
} }
public function testItDoesNotRenderSubscriberShortcodeInSubjectWhenPreprocessingNewsletter() { public function testItDoesNotRenderSubscriberShortcodeInSubjectWhenPreprocessingNewsletter() {
$newsletter = $this->newsletter; $this->newsletter->setSubject('Newsletter for [subscriber:firstname] [date:dordinal]');
$newsletter->subject = 'Newsletter for [subscriber:firstname] [date:dordinal]'; $this->newslettersRepository->persist($this->newsletter);
$newsletter = $this->newsletterTask->preProcessNewsletter($newsletter, $this->sendingTask); $this->newslettersRepository->flush();
$this->sendingTask = SendingTask::getByNewsletterId($newsletter->id); $this->newsletter = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$this->sendingTask = SendingTask::getByNewsletterId($this->newsletter->getId());
$wp = new WPFunctions(); $wp = new WPFunctions();
expect($this->sendingTask->newsletterRenderedSubject) expect($this->sendingTask->newsletterRenderedSubject)
->stringContainsString(date_i18n('jS', $wp->currentTime('timestamp'))); ->stringContainsString(date_i18n('jS', $wp->currentTime('timestamp')));
} }
public function testItUsesADefaultSubjectIfRenderedSubjectIsEmptyWhenPreprocessingNewsletter() { public function testItUsesADefaultSubjectIfRenderedSubjectIsEmptyWhenPreprocessingNewsletter() {
$newsletter = $this->newsletter; $this->newsletter->setSubject(' [custom_shortcode:should_render_empty] ');
$newsletter->subject = ' [custom_shortcode:should_render_empty] '; $this->newslettersRepository->persist($this->newsletter);
$newsletter = $this->newsletterTask->preProcessNewsletter($newsletter, $this->sendingTask); $this->newslettersRepository->flush();
$this->sendingTask = SendingTask::getByNewsletterId($newsletter->id); $this->newsletter = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$this->sendingTask = SendingTask::getByNewsletterId($this->newsletter->getId());
expect($this->sendingTask->newsletterRenderedSubject) expect($this->sendingTask->newsletterRenderedSubject)
->equals('No subject'); ->equals('No subject');
} }
public function testItUsesRenderedNewsletterBodyAndSubjectFromQueueObjectWhenPreparingNewsletterForSending() { public function testItUsesRenderedNewsletterBodyAndSubjectFromQueueObjectWhenPreparingNewsletterForSending() {
$newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id); $newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->sendingTask->newsletterRenderedBody = [ $this->sendingTask->newsletterRenderedBody = [
'html' => 'queue HTML body', 'html' => 'queue HTML body',
@ -330,7 +335,7 @@ class NewsletterTest extends \MailPoetTest {
public function testItRendersShortcodesAndReplacesSubscriberDataInLinks() { public function testItRendersShortcodesAndReplacesSubscriberDataInLinks() {
$newsletter = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $newsletter = $this->newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$newsletterEntity = $this->newslettersRepository->findOneById($newsletter->id); $newsletterEntity = $this->newslettersRepository->findOneById($newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$result = $this->newsletterTask->prepareNewsletterForSending( $result = $this->newsletterTask->prepareNewsletterForSending(
$newsletterEntity, $newsletterEntity,
@ -348,7 +353,7 @@ class NewsletterTest extends \MailPoetTest {
$newsletterTask = $this->newsletterTask; $newsletterTask = $this->newsletterTask;
$newsletterTask->trackingEnabled = false; $newsletterTask->trackingEnabled = false;
$newsletter = $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask); $newsletter = $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
$newsletterEntity = $this->newslettersRepository->findOneById($newsletter->id); $newsletterEntity = $this->newslettersRepository->findOneById($newsletter->getId());
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity); $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$result = $newsletterTask->prepareNewsletterForSending( $result = $newsletterTask->prepareNewsletterForSending(
$newsletterEntity, $newsletterEntity,