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

Replace repeating code with using factory

Browse Source 
[MAILPOET-4141]
This commit is contained in:
Jan Lysý
2022-06-03 14:48:10 +02:00
committed by Veljko V
parent 74ec1cfac2
commit d340909187
7 changed files with 56 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
mailpoet/tests/integration/API/JSON/v1/SendingQueueTest.php
View File

@ -1,4 +1,4 @@
<?php <?php declare(strict_types = 1);
namespace MailPoet\Test\API\JSON\v1; namespace MailPoet\Test\API\JSON\v1;
@ -11,22 +11,25 @@ use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\ScheduledTaskEntity; use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\SendingQueueEntity; use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Newsletter\NewsletterValidator; use MailPoet\Newsletter\NewsletterValidator;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Newsletter\Sending\ScheduledTasksRepository; use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
use MailPoet\Settings\SettingsController; use MailPoet\Settings\SettingsController;
use MailPoet\Settings\SettingsRepository; use MailPoet\Settings\SettingsRepository;
use MailPoet\Tasks\Sending; use MailPoet\Tasks\Sending;
use MailPoet\Test\DataFactories\Newsletter; use MailPoet\Test\DataFactories\Newsletter;
use MailPoet\Test\DataFactories\NewsletterOption;
use MailPoet\Util\License\Features\Subscribers as SubscribersFeature; use MailPoet\Util\License\Features\Subscribers as SubscribersFeature;
class SendingQueueTest extends \MailPoetTest { class SendingQueueTest extends \MailPoetTest {
/** @var NewsletterEntity */ /** @var NewsletterEntity */
private $newsletter; private $newsletter;
/** @var NewsletterOption */
private $newsletterOptionsFactory;
public function _before() { public function _before() {
parent::_before(); parent::_before();
$this->clean(); $this->clean();
$this->newsletterOptionsFactory = new NewsletterOption();
$this->newsletter = (new Newsletter()) $this->newsletter = (new Newsletter())
->withSubject('My Standard Newsletter') ->withSubject('My Standard Newsletter')
@ -44,15 +47,11 @@ class SendingQueueTest extends \MailPoetTest {
$newsletter = $this->newsletter; $newsletter = $this->newsletter;
$newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED); $newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED);
$this->entityManager->flush(); $this->entityManager->flush();
$newletterOptions = [ $newsletterOptions = [
'isScheduled' => 1, 'isScheduled' => 1,
'scheduledAt' => '2018-10-10 10:00:00', 'scheduledAt' => '2018-10-10 10:00:00',
]; ];
$this->_createOrUpdateNewsletterOptions( $this->newsletterOptionsFactory->createMultipleOptions($newsletter, $newsletterOptions);
$newsletter,
NewsletterEntity::TYPE_STANDARD,
$newletterOptions
);
$sendingQueue = $this->diContainer->get(SendingQueueAPI::class); $sendingQueue = $this->diContainer->get(SendingQueueAPI::class);
$result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]); $result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]);
@ -62,7 +61,7 @@ class SendingQueueTest extends \MailPoetTest {
expect($scheduledTask->getStatus())->equals(ScheduledTaskEntity::STATUS_SCHEDULED); expect($scheduledTask->getStatus())->equals(ScheduledTaskEntity::STATUS_SCHEDULED);
$scheduled = $scheduledTask->getScheduledAt(); $scheduled = $scheduledTask->getScheduledAt();
$this->assertInstanceOf(\DateTimeInterface::class, $scheduled); $this->assertInstanceOf(\DateTimeInterface::class, $scheduled);
expect($scheduled->format('Y-m-d H:i:s'))->equals($newletterOptions['scheduledAt']); expect($scheduled->format('Y-m-d H:i:s'))->equals($newsletterOptions['scheduledAt']);
expect($scheduledTask->getType())->equals(Sending::TASK_TYPE); expect($scheduledTask->getType())->equals(Sending::TASK_TYPE);
} }
@ -82,15 +81,11 @@ class SendingQueueTest extends \MailPoetTest {
$newsletter = $this->newsletter; $newsletter = $this->newsletter;
$newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED); $newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED);
$this->entityManager->flush(); $this->entityManager->flush();
$newletterOptions = [ $newsletterOptions = [
'isScheduled' => 1, 'isScheduled' => 1,
'scheduledAt' => '2018-10-10 10:00:00', 'scheduledAt' => '2018-10-10 10:00:00',
]; ];
$this->_createOrUpdateNewsletterOptions( $this->newsletterOptionsFactory->createMultipleOptions($newsletter, $newsletterOptions);
$newsletter,
NewsletterEntity::TYPE_STANDARD,
$newletterOptions
);
$sendingQueue = $this->diContainer->get(SendingQueueAPI::class); $sendingQueue = $this->diContainer->get(SendingQueueAPI::class);
// add scheduled task // add scheduled task
@ -103,14 +98,10 @@ class SendingQueueTest extends \MailPoetTest {
expect($scheduled->format('Y-m-d H:i:s'))->equals('2018-10-10 10:00:00'); expect($scheduled->format('Y-m-d H:i:s'))->equals('2018-10-10 10:00:00');
// update scheduled time // update scheduled time
$newletterOptions = [ $newsletterOptions = [
'scheduledAt' => '2018-11-11 11:00:00', 'scheduledAt' => '2018-11-11 11:00:00',
]; ];
$this->_createOrUpdateNewsletterOptions( $this->newsletterOptionsFactory->createMultipleOptions($newsletter, $newsletterOptions);
$newsletter,
NewsletterEntity::TYPE_STANDARD,
$newletterOptions
);
$result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]); $result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]);
$repo = $this->diContainer->get(ScheduledTasksRepository::class); $repo = $this->diContainer->get(ScheduledTasksRepository::class);
$this->entityManager->clear(); $this->entityManager->clear();
@ -135,30 +126,6 @@ class SendingQueueTest extends \MailPoetTest {
expect($response['errors'][0]['error'])->stringContainsString('bad_request'); expect($response['errors'][0]['error'])->stringContainsString('bad_request');
} }
private function _createOrUpdateNewsletterOptions(NewsletterEntity $newsletter, $newsletterType, $options) {
$newsletterOptionFieldRepository = $this->diContainer->get(NewsletterOptionFieldsRepository::class);
$newsletterOptionRepository = $this->diContainer->get(NewsletterOptionsRepository::class);
foreach ($options as $option => $value) {
$newsletterOptionField = $newsletterOptionFieldRepository->findOneBy(['name' => $option]);
if (!$newsletterOptionField instanceof NewsletterOptionFieldEntity) {
$newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->setName($option);
$newsletterOptionField->setNewsletterType($newsletterType);
$this->entityManager->persist($newsletterOptionField);
}
$newsletterOption = $newsletterOptionRepository->findOneBy(['newsletter' => $newsletter, 'optionField' => $newsletterOptionField]);
if (!$newsletterOption instanceof NewsletterOptionEntity) {
$newsletterOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
$newsletter->getOptions()->add($newsletterOption);
$this->entityManager->persist($newsletterOption);
}
$newsletterOption->setValue($value);
}
$this->entityManager->flush();
}
public function clean() { public function clean() {
$this->diContainer->get(SettingsRepository::class)->truncate(); $this->diContainer->get(SettingsRepository::class)->truncate();
$this->truncateEntity(NewsletterEntity::class); $this->truncateEntity(NewsletterEntity::class);

47
mailpoet/tests/integration/AutomaticEmails/WooCommerce/Events/AbandonedCartTest.php
View File

@ -1,4 +1,4 @@
<?php <?php declare(strict_types = 1);
namespace MailPoet\AutomaticEmails\WooCommerce\Events; namespace MailPoet\AutomaticEmails\WooCommerce\Events;
@ -11,13 +11,11 @@ use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity; use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity; use MailPoet\Entities\SubscriberEntity;
use MailPoet\Newsletter\NewslettersRepository; use MailPoet\Newsletter\NewslettersRepository;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Newsletter\Scheduler\AutomaticEmailScheduler; use MailPoet\Newsletter\Scheduler\AutomaticEmailScheduler;
use MailPoet\Newsletter\Scheduler\Scheduler;
use MailPoet\Newsletter\Sending\ScheduledTasksRepository; use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
use MailPoet\Newsletter\Sending\ScheduledTaskSubscribersRepository; use MailPoet\Newsletter\Sending\ScheduledTaskSubscribersRepository;
use MailPoet\Newsletter\Sending\SendingQueuesRepository; use MailPoet\Newsletter\Sending\SendingQueuesRepository;
use MailPoet\Newsletter\Scheduler\Scheduler;
use MailPoet\Settings\SettingsController; use MailPoet\Settings\SettingsController;
use MailPoet\Settings\TrackingConfig; use MailPoet\Settings\TrackingConfig;
use MailPoet\Statistics\Track\SubscriberActivityTracker; use MailPoet\Statistics\Track\SubscriberActivityTracker;
@ -25,6 +23,7 @@ use MailPoet\Statistics\Track\SubscriberCookie;
use MailPoet\Subscribers\SubscribersRepository; use MailPoet\Subscribers\SubscribersRepository;
use MailPoet\Tasks\Sending as SendingTask; use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory; use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory; use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory;
use MailPoet\Util\Cookies; use MailPoet\Util\Cookies;
use MailPoet\WooCommerce\Helper as WooCommerceHelper; use MailPoet\WooCommerce\Helper as WooCommerceHelper;
@ -56,12 +55,6 @@ class AbandonedCartTest extends \MailPoetTest {
/** @var SubscriberActivityTracker&MockObject */ /** @var SubscriberActivityTracker&MockObject */
private $subscriberActivityTrackerMock; private $subscriberActivityTrackerMock;
/** @var NewsletterOptionFieldsRepository */
private $newsletterOptionFieldsRepository;
/** @var NewsletterOptionsRepository */
private $newsletterOptionsRepository;
/** @var ScheduledTasksRepository */ /** @var ScheduledTasksRepository */
private $scheduledTasksRepository; private $scheduledTasksRepository;
@ -77,8 +70,6 @@ class AbandonedCartTest extends \MailPoetTest {
public function _before() { public function _before() {
$this->cleanup(); $this->cleanup();
$this->newsletterOptionFieldsRepository = $this->diContainer->get(NewsletterOptionFieldsRepository::class);
$this->newsletterOptionsRepository = $this->diContainer->get(NewsletterOptionsRepository::class);
$this->scheduledTasksRepository = $this->diContainer->get(ScheduledTasksRepository::class); $this->scheduledTasksRepository = $this->diContainer->get(ScheduledTasksRepository::class);
$this->sendingQueuesRepository = $this->diContainer->get(SendingQueuesRepository::class); $this->sendingQueuesRepository = $this->diContainer->get(SendingQueuesRepository::class);
$this->scheduledTaskSubscribersRepository = $this->diContainer->get(ScheduledTaskSubscribersRepository::class); $this->scheduledTaskSubscribersRepository = $this->diContainer->get(ScheduledTaskSubscribersRepository::class);
@ -320,7 +311,7 @@ class AbandonedCartTest extends \MailPoetTest {
->withActiveStatus() ->withActiveStatus()
->create(); ->create();
$this->createNewsletterOptions($newsletter, [ (new NewsletterOptionFactory())->createMultipleOptions($newsletter, [
'group' => WooCommerceEmail::SLUG, 'group' => WooCommerceEmail::SLUG,
'event' => AbandonedCart::SLUG, 'event' => AbandonedCart::SLUG,
'afterTimeType' => 'hours', 'afterTimeType' => 'hours',
@ -353,36 +344,6 @@ class AbandonedCartTest extends \MailPoetTest {
return $scheduledTask; return $scheduledTask;
} }
private function createNewsletterOptions(NewsletterEntity $newsletter, array $options): void {
foreach ($options as $option => $value) {
$newsletterOptionField = $this->newsletterOptionFieldsRepository->findOneBy([
'name' => $option,
'newsletterType' => $newsletter->getType(),
]);
if (!$newsletterOptionField) {
$newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->setNewsletterType($newsletter->getType());
$newsletterOptionField->setName($option);
$this->newsletterOptionFieldsRepository->persist($newsletterOptionField);
$this->newsletterOptionFieldsRepository->flush();
}
$newsletterOption = $this->newsletterOptionsRepository->findOneBy([
'newsletter' => $newsletter,
'optionField' => $newsletterOptionField,
]);
if (!$newsletterOption) {
$newsletterOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
$newsletterOption->setValue($value);
$newsletter->getOptions()->add($newsletterOption);
$this->newsletterOptionsRepository->persist($newsletterOption);
$this->newsletterOptionsRepository->flush();
}
}
}
private function createSubscriber(): SubscriberEntity { private function createSubscriber(): SubscriberEntity {
return (new SubscriberFactory()) return (new SubscriberFactory())
->withWpUserId(123) ->withWpUserId(123)

25
mailpoet/tests/integration/Newsletter/Blocks/AbandonedCartContentTest.php
View File

@ -10,6 +10,7 @@ use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\NewsletterPostEntity; use MailPoet\Entities\NewsletterPostEntity;
use MailPoet\Newsletter\NewslettersRepository; use MailPoet\Newsletter\NewslettersRepository;
use MailPoet\Newsletter\Scheduler\AutomaticEmailScheduler; use MailPoet\Newsletter\Scheduler\AutomaticEmailScheduler;
use MailPoet\Test\DataFactories\NewsletterOption;
use MailPoet\WP\Functions as WPFunctions; use MailPoet\WP\Functions as WPFunctions;
class AbandonedCartContentTest extends \MailPoetTest { class AbandonedCartContentTest extends \MailPoetTest {
@ -172,26 +173,10 @@ class AbandonedCartContentTest extends \MailPoetTest {
} }
private function setGroupAndEventOptions($newsletter, $group = WooCommerceEmail::SLUG, $event = AbandonedCart::SLUG) { private function setGroupAndEventOptions($newsletter, $group = WooCommerceEmail::SLUG, $event = AbandonedCart::SLUG) {
$newsletterOptionField = new NewsletterOptionFieldEntity(); (new NewsletterOption())->createMultipleOptions($newsletter, [
$newsletterOptionField->setName('group'); NewsletterOptionFieldEntity::NAME_GROUP => $group,
$newsletterOptionField->setNewsletterType(NewsletterEntity::TYPE_AUTOMATIC); NewsletterOptionFieldEntity::NAME_EVENT => $event,
$this->entityManager->persist($newsletterOptionField); ]);
$newsletterOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
$newsletterOption->setValue($group);
$this->entityManager->persist($newsletterOption);
$newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->setName('event');
$newsletterOptionField->setNewsletterType(NewsletterEntity::TYPE_AUTOMATIC);
$this->entityManager->persist($newsletterOptionField);
$newsletterOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
$newsletterOption->setValue($event);
$this->entityManager->persist($newsletterOption);
$this->entityManager->flush();
$this->entityManager->refresh($newsletter);
} }
private function createSendingTask($newsletter, $subscriberId = null, $meta = null) { private function createSendingTask($newsletter, $subscriberId = null, $meta = null) {

50
mailpoet/tests/integration/Newsletter/Scheduler/PostNotificationTest.php
View File

@ -15,9 +15,9 @@ use MailPoet\Models\Newsletter;
use MailPoet\Models\SendingQueue; use MailPoet\Models\SendingQueue;
use MailPoet\Newsletter\NewsletterPostsRepository; use MailPoet\Newsletter\NewsletterPostsRepository;
use MailPoet\Newsletter\NewslettersRepository; use MailPoet\Newsletter\NewslettersRepository;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository; use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Tasks\Sending as SendingTask; use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionsFactory;
use MailPoet\WP\Functions as WPFunctions; use MailPoet\WP\Functions as WPFunctions;
use MailPoet\WP\Posts as WPPosts; use MailPoet\WP\Posts as WPPosts;
use MailPoetVendor\Carbon\Carbon; use MailPoetVendor\Carbon\Carbon;
@ -36,29 +36,29 @@ class PostNotificationTest extends \MailPoetTest {
/** @var NewsletterOptionsRepository */ /** @var NewsletterOptionsRepository */
private $newsletterOptionsRepository; private $newsletterOptionsRepository;
/** @var NewsletterOptionFieldsRepository */
private $newsletterOptionFieldsRepository;
/** @var Hooks */ /** @var Hooks */
private $hooks; private $hooks;
/** @var Scheduler */ /** @var Scheduler */
private $scheduler; private $scheduler;
/** @var NewsletterOptionsFactory */
private $newsletterOptionsFactory;
public function _before() { public function _before() {
parent::_before(); parent::_before();
$this->postNotificationScheduler = $this->diContainer->get(PostNotificationScheduler::class); $this->postNotificationScheduler = $this->diContainer->get(PostNotificationScheduler::class);
$this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class); $this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
$this->newsletterPostsRepository = $this->diContainer->get(NewsletterPostsRepository::class); $this->newsletterPostsRepository = $this->diContainer->get(NewsletterPostsRepository::class);
$this->newsletterOptionsRepository = $this->diContainer->get(NewsletterOptionsRepository::class); $this->newsletterOptionsRepository = $this->diContainer->get(NewsletterOptionsRepository::class);
$this->newsletterOptionFieldsRepository = $this->diContainer->get(NewsletterOptionFieldsRepository::class); $this->newsletterOptionsFactory = new NewsletterOptionsFactory();
$this->hooks = $this->diContainer->get(Hooks::class); $this->hooks = $this->diContainer->get(Hooks::class);
$this->scheduler = $this->diContainer->get(Scheduler::class); $this->scheduler = $this->diContainer->get(Scheduler::class);
} }
public function testItCreatesPostNotificationSendingTask() { public function testItCreatesPostNotificationSendingTask() {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_SCHEDULE => '* 5 * * *', NewsletterOptionFieldEntity::NAME_SCHEDULE => '* 5 * * *',
]); ]);
@ -83,7 +83,7 @@ class PostNotificationTest extends \MailPoetTest {
public function testItCreatesPostNotificationSendingTaskIfAPausedNotificationExists() { public function testItCreatesPostNotificationSendingTaskIfAPausedNotificationExists() {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_SCHEDULE => '* 5 * * *', NewsletterOptionFieldEntity::NAME_SCHEDULE => '* 5 * * *',
]); ]);
@ -128,7 +128,7 @@ class PostNotificationTest extends \MailPoetTest {
public function testItSchedulesPostNotification() { public function testItSchedulesPostNotification() {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_SCHEDULE => '0 5 * * *', NewsletterOptionFieldEntity::NAME_SCHEDULE => '0 5 * * *',
]); ]);
@ -146,7 +146,7 @@ class PostNotificationTest extends \MailPoetTest {
public function testItProcessesPostNotificationScheduledForDailyDelivery() { public function testItProcessesPostNotificationScheduledForDailyDelivery() {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_DAILY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_DAILY,
NewsletterOptionFieldEntity::NAME_MONTH_DAY => null, NewsletterOptionFieldEntity::NAME_MONTH_DAY => null,
NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null, NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null,
@ -168,7 +168,7 @@ class PostNotificationTest extends \MailPoetTest {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
// weekly notification is scheduled every Tuesday at 14:00 // weekly notification is scheduled every Tuesday at 14:00
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_WEEKLY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_WEEKLY,
NewsletterOptionFieldEntity::NAME_MONTH_DAY => null, NewsletterOptionFieldEntity::NAME_MONTH_DAY => null,
NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null, NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null,
@ -190,7 +190,7 @@ class PostNotificationTest extends \MailPoetTest {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
// monthly notification is scheduled every 20th day at 14:00 // monthly notification is scheduled every 20th day at 14:00
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_MONTHLY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_MONTHLY,
NewsletterOptionFieldEntity::NAME_MONTH_DAY => 19, NewsletterOptionFieldEntity::NAME_MONTH_DAY => 19,
NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null, NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null,
@ -211,7 +211,7 @@ class PostNotificationTest extends \MailPoetTest {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
// monthly notification is scheduled every last Saturday at 14:00 // monthly notification is scheduled every last Saturday at 14:00
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_NTHWEEKDAY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_NTHWEEKDAY,
NewsletterOptionFieldEntity::NAME_MONTH_DAY => null, NewsletterOptionFieldEntity::NAME_MONTH_DAY => null,
NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => 'L', // L = last NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => 'L', // L = last
@ -232,7 +232,7 @@ class PostNotificationTest extends \MailPoetTest {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
// notification is scheduled immediately (next minute) // notification is scheduled immediately (next minute)
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_IMMEDIATELY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_IMMEDIATELY,
NewsletterOptionFieldEntity::NAME_MONTH_DAY => null, NewsletterOptionFieldEntity::NAME_MONTH_DAY => null,
NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null, NewsletterOptionFieldEntity::NAME_NTH_WEEK_DAY => null,
@ -252,7 +252,7 @@ class PostNotificationTest extends \MailPoetTest {
public function testUnsearchablePostTypeDoesNotSchedulePostNotification() { public function testUnsearchablePostTypeDoesNotSchedulePostNotification() {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_IMMEDIATELY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_IMMEDIATELY,
NewsletterOptionFieldEntity::NAME_SCHEDULE => '* * * * *', NewsletterOptionFieldEntity::NAME_SCHEDULE => '* * * * *',
]); ]);
@ -283,7 +283,7 @@ class PostNotificationTest extends \MailPoetTest {
public function testSchedulerWontRunIfUnsentNotificationHistoryExists() { public function testSchedulerWontRunIfUnsentNotificationHistoryExists() {
$newsletter = $this->createNewsletter(); $newsletter = $this->createNewsletter();
$this->createNewsletterOptions($newsletter, [ $this->newsletterOptionsFactory->createMultipleOptions($newsletter, [
NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_IMMEDIATELY, NewsletterOptionFieldEntity::NAME_INTERVAL_TYPE => PostNotificationScheduler::INTERVAL_IMMEDIATELY,
NewsletterOptionFieldEntity::NAME_SCHEDULE => '* * * * *', NewsletterOptionFieldEntity::NAME_SCHEDULE => '* * * * *',
]); ]);
@ -343,26 +343,6 @@ class PostNotificationTest extends \MailPoetTest {
return $newsletterPost; return $newsletterPost;
} }
private function createNewsletterOptions(NewsletterEntity $newsletter, array $options) {
foreach ($options as $name => $value) {
$newsletterOptionField = $this->newsletterOptionFieldsRepository->findOneBy([
'name' => $name,
]);
if ($newsletterOptionField === null) {
$newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->setName($name);
$newsletterOptionField->setNewsletterType(NewsletterEntity::TYPE_NOTIFICATION);
$this->newsletterOptionFieldsRepository->persist($newsletterOptionField);
}
$scheduleOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
$scheduleOption->setValue($value);
$newsletter->getOptions()->add($scheduleOption);
$this->newsletterOptionsRepository->persist($scheduleOption);
}
$this->newsletterOptionsRepository->flush();
}
public function _after() { public function _after() {
Carbon::setTestNow(); Carbon::setTestNow();
$this->truncateEntity(NewsletterEntity::class); $this->truncateEntity(NewsletterEntity::class);

35
mailpoet/tests/integration/Newsletter/Scheduler/WelcomeTest.php
View File

@ -15,6 +15,7 @@ use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
use MailPoet\Segments\SegmentsRepository; use MailPoet\Segments\SegmentsRepository;
use MailPoet\Subscribers\SubscribersRepository; use MailPoet\Subscribers\SubscribersRepository;
use MailPoet\Tasks\Sending as SendingTask; use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\NewsletterOption;
use MailPoet\WP\Functions as WPFunctions; use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon; use MailPoetVendor\Carbon\Carbon;
@ -91,6 +92,7 @@ class WelcomeTest extends \MailPoetTest {
$welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId()); $welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
expect($queue->getId())->greaterOrEquals(1); expect($queue->getId())->greaterOrEquals(1);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
@ -115,6 +117,7 @@ class WelcomeTest extends \MailPoetTest {
$welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId()); $welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
expect($queue->getId())->greaterOrEquals(1); expect($queue->getId())->greaterOrEquals(1);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
@ -139,6 +142,7 @@ class WelcomeTest extends \MailPoetTest {
$welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId()); $welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
expect($queue->getId())->greaterOrEquals(1); expect($queue->getId())->greaterOrEquals(1);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
@ -164,6 +168,7 @@ class WelcomeTest extends \MailPoetTest {
$welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId()); $welcomeScheduler->createWelcomeNotificationSendingTask($newsletter, $this->subscriber->getId());
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
expect($queue->getId())->greaterOrEquals(1); expect($queue->getId())->greaterOrEquals(1);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
@ -213,6 +218,7 @@ class WelcomeTest extends \MailPoetTest {
Carbon::setTestNow($currentTime); // mock carbon to return current time Carbon::setTestNow($currentTime); // mock carbon to return current time
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
$scheduledAt = $task->getScheduledAt(); $scheduledAt = $task->getScheduledAt();
@ -374,14 +380,15 @@ class WelcomeTest extends \MailPoetTest {
] ]
); );
$this->welcomeScheduler->scheduleWPUserWelcomeNotification( $this->welcomeScheduler->scheduleWPUserWelcomeNotification(
$subscriberId = $this->subscriber->getId(), $this->subscriber->getId(),
$wpUser = ['roles' => ['administrator']] ['roles' => ['administrator']]
); );
$currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
Carbon::setTestNow($currentTime); // mock carbon to return current time Carbon::setTestNow($currentTime); // mock carbon to return current time
// queue is created and scheduled for delivery one day later // queue is created and scheduled for delivery one day later
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
$scheduledAt = $task->getScheduledAt(); $scheduledAt = $task->getScheduledAt();
@ -402,13 +409,14 @@ class WelcomeTest extends \MailPoetTest {
); );
$this->welcomeScheduler->scheduleWPUserWelcomeNotification( $this->welcomeScheduler->scheduleWPUserWelcomeNotification(
$this->subscriber->getId(), $this->subscriber->getId(),
$wpUser = ['roles' => ['administrator']] ['roles' => ['administrator']]
); );
$currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp')); $currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
Carbon::setTestNow($currentTime); // mock carbon to return current time Carbon::setTestNow($currentTime); // mock carbon to return current time
// queue is created and scheduled for delivery one day later // queue is created and scheduled for delivery one day later
$this->entityManager->refresh($newsletter); $this->entityManager->refresh($newsletter);
$queue = $newsletter->getLatestQueue(); $queue = $newsletter->getLatestQueue();
$this->assertInstanceOf(SendingQueueEntity::class, $queue);
$task = $queue->getTask(); $task = $queue->getTask();
assert($task instanceof ScheduledTaskEntity); assert($task instanceof ScheduledTaskEntity);
$scheduledAt = $task->getScheduledAt(); $scheduledAt = $task->getScheduledAt();
@ -427,24 +435,9 @@ class WelcomeTest extends \MailPoetTest {
return $newsletter; return $newsletter;
} }
private function configureNewsletterWithOptions(NewsletterEntity $newsletter, array $options) { private function configureNewsletterWithOptions(NewsletterEntity $newsletter, array $options): NewsletterEntity {
foreach ($options as $optionFieldName => $optionValue) { $newsletterOptionsFactory = new NewsletterOption();
$optionField = $this->entityManager->getRepository(NewsletterOptionFieldEntity::class)->findOneBy([ $newsletterOptionsFactory->createMultipleOptions($newsletter, $options);
'name' => $optionFieldName,
'newsletterType' => NewsletterEntity::TYPE_WELCOME,
]);
if (!$optionField instanceof NewsletterOptionFieldEntity) {
$optionField = new NewsletterOptionFieldEntity();
$optionField->setNewsletterType(NewsletterEntity::TYPE_WELCOME);
$optionField->setName($optionFieldName);
$this->entityManager->persist($optionField);
}
$option = new NewsletterOptionEntity($newsletter, $optionField);
$option->setValue($optionValue);
$this->entityManager->persist($option);
$newsletter->getOptions()->add($option);
}
$this->entityManager->flush();
return $newsletter; return $newsletter;
} }

33
mailpoet/tests/integration/Subscribers/SubscriberActionsTest.php
View File

@ -15,6 +15,7 @@ use MailPoet\Newsletter\Sending\SendingQueuesRepository;
use MailPoet\Segments\SegmentsRepository; use MailPoet\Segments\SegmentsRepository;
use MailPoet\Settings\SettingsController; use MailPoet\Settings\SettingsController;
use MailPoet\Settings\SettingsRepository; use MailPoet\Settings\SettingsRepository;
use MailPoet\Test\DataFactories\NewsletterOption;
class SubscriberActionsTest extends \MailPoetTest { class SubscriberActionsTest extends \MailPoetTest {
@ -82,10 +83,7 @@ class SubscriberActionsTest extends \MailPoetTest {
NewsletterOptionFieldEntity::NAME_AFTER_TIME_TYPE => 'days', NewsletterOptionFieldEntity::NAME_AFTER_TIME_TYPE => 'days',
NewsletterOptionFieldEntity::NAME_AFTER_TIME_NUMBER => 1, NewsletterOptionFieldEntity::NAME_AFTER_TIME_NUMBER => 1,
]; ];
foreach ($newsletterOptions as $option => $value) { (new NewsletterOption())->createMultipleOptions($newsletter, $newsletterOptions);
$newsletterOptionField = $this->createNewsletterOptionField($option, $newsletter->getType());
$newsletterOption = $this->createNewsletterOption($newsletter, $newsletterOptionField, (string)$value);
}
$this->settings->set('signup_confirmation.enabled', false); $this->settings->set('signup_confirmation.enabled', false);
$subscriber = $this->subscriberActions->subscribe($this->testData, [$segment->getId()]); $subscriber = $this->subscriberActions->subscribe($this->testData, [$segment->getId()]);
@ -112,10 +110,7 @@ class SubscriberActionsTest extends \MailPoetTest {
'afterTimeType' => 'days', 'afterTimeType' => 'days',
'afterTimeNumber' => 1, 'afterTimeNumber' => 1,
]; ];
foreach ($newsletterOptions as $option => $value) { (new NewsletterOption())->createMultipleOptions($newsletter, $newsletterOptions);
$newsletterOptionField = $this->createNewsletterOptionField($option, $newsletter->getType());
$newsletterOption = $this->createNewsletterOption($newsletter, $newsletterOptionField, (string)$value);
}
$this->settings->set('signup_confirmation.enabled', true); $this->settings->set('signup_confirmation.enabled', true);
$subscriber = $this->subscriberActions->subscribe($this->testData, [$segment->getId()]); $subscriber = $this->subscriberActions->subscribe($this->testData, [$segment->getId()]);
@ -272,28 +267,6 @@ class SubscriberActionsTest extends \MailPoetTest {
return $newsletter; return $newsletter;
} }
private function createNewsletterOptionField(string $option, string $type): NewsletterOptionFieldEntity {
$newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->setName($option);
$newsletterOptionField->setNewsletterType($type);
$this->entityManager->persist($newsletterOptionField);
$this->entityManager->flush();
return $newsletterOptionField;
}
private function createNewsletterOption(
NewsletterEntity $newsletter,
NewsletterOptionFieldEntity $optionField,
string $value
): NewsletterOptionEntity {
$newsletterOption = new NewsletterOptionEntity($newsletter, $optionField);
$newsletterOption->setValue($value);
$newsletter->getOptions()->add($newsletterOption);
$this->entityManager->persist($newsletterOption);
$this->entityManager->flush();
return $newsletterOption;
}
public function _after() { public function _after() {
$this->truncateEntity(SubscriberEntity::class); $this->truncateEntity(SubscriberEntity::class);
$this->truncateEntity(SegmentEntity::class); $this->truncateEntity(SegmentEntity::class);

13
mailpoet/tests/integration/Subscription/PagesTest.php
View File

@ -32,6 +32,7 @@ use MailPoet\Subscription\CaptchaRenderer;
use MailPoet\Subscription\ManageSubscriptionFormRenderer; use MailPoet\Subscription\ManageSubscriptionFormRenderer;
use MailPoet\Subscription\Pages; use MailPoet\Subscription\Pages;
use MailPoet\Subscription\SubscriptionUrlFactory; use MailPoet\Subscription\SubscriptionUrlFactory;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\Test\DataFactories\Segment as SegmentFactory; use MailPoet\Test\DataFactories\Segment as SegmentFactory;
use MailPoet\WP\Functions as WPFunctions; use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon; use MailPoetVendor\Carbon\Carbon;
@ -144,17 +145,7 @@ class PagesTest extends \MailPoetTest {
'afterTimeType' => 'days', 'afterTimeType' => 'days',
'afterTimeNumber' => 1, 'afterTimeNumber' => 1,
]; ];
foreach ($newsletterOptions as $option => $value) { (new NewsletterOptionFactory())->createMultipleOptions($newsletter, $newsletterOptions);
$newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->setName($option);
$newsletterOptionField->setNewsletterType($newsletter->getType());
$this->entityManager->persist($newsletterOptionField);
$newsletterOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
$newsletterOption->setValue((string)$value);
$newsletter->getOptions()->add($newsletterOption);
$this->entityManager->persist($newsletterOption);
}
// confirm subscription and ensure that welcome email is scheduled // confirm subscription and ensure that welcome email is scheduled
$subscription->confirm(); $subscription->confirm();