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

Replace NewsletterOption and NewsletterOptionField models

Browse Source 
This commit repleaces the old NewsletterOption and NewsletterOptionField
models with Doctrine code in several test classes.

[MAILPOET-4150]
This commit is contained in:
Rodrigo Primo
2022-05-11 17:09:53 -03:00
committed by Veljko V
parent f48bb5758c
commit d89067854c
8 changed files with 343 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
mailpoet/tests/integration/API/JSON/v1/SubscribersTest.php
View File

@@ -24,9 +24,6 @@ use MailPoet\Entities\SubscriberSegmentEntity;
use MailPoet\Form\Util\FieldNameObfuscator;
use MailPoet\Listing\Handler;
use MailPoet\Models\CustomField;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\Subscriber;
@@ -43,6 +40,8 @@ use MailPoet\Subscribers\SubscriberSubscribeController;
use MailPoet\Subscription\Captcha;
use MailPoet\Subscription\CaptchaSession;
use MailPoet\Test\DataFactories\DynamicSegment;
use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\UnexpectedValueException;
use MailPoet\WP\Functions;
use MailPoetVendor\Carbon\Carbon;
@@ -988,32 +987,23 @@ class SubscribersTest extends \MailPoetTest {
}
private function _createWelcomeNewsletter() {
$welcomeNewsletter = Newsletter::create();
$welcomeNewsletter->type = Newsletter::TYPE_WELCOME;
$welcomeNewsletter->status = Newsletter::STATUS_ACTIVE;
$welcomeNewsletter->save();
expect($welcomeNewsletter->getErrors())->false();
$newsletterFactory = new NewsletterFactory();
$welcomeNewsletter = $newsletterFactory
->withActiveStatus()
->create();
$welcomeNewsletter->setType(NewsletterEntity::TYPE_WELCOME);
$this->entityManager->persist($welcomeNewsletter);
$this->entityManager->flush();
$welcomeNewsletterOptions = [
'event' => 'segment',
'segment' => $this->segment1->getId(),
'schedule' => '* * * * *',
];
foreach ($welcomeNewsletterOptions as $option => $value) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $option;
$newsletterOptionField->newsletterType = Newsletter::TYPE_WELCOME;
$newsletterOptionField->save();
expect($newsletterOptionField->getErrors())->false();
$newsletterOption = NewsletterOption::create();
$newsletterOption->optionFieldId = (int)$newsletterOptionField->id;
$newsletterOption->newsletterId = $welcomeNewsletter->id;
$newsletterOption->value = (string)$value;
$newsletterOption->save();
expect($newsletterOption->getErrors())->false();
}
$newsletterOptionFactory = new NewsletterOptionFactory();
$newsletterOptionFactory->createMultipleOptions(
$welcomeNewsletter,
[
'event' => 'segment',
'segment' => $this->segment1->getId(),
'schedule' => '* * * * *',
]
);
}
public function _after() {

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

@@ -3,10 +3,14 @@
namespace MailPoet\AutomaticEmails\WooCommerce\Events;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerce as WooCommerceEmail;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\ScheduledTaskSubscriber;
use MailPoet\Models\SendingQueue;
@@ -16,12 +20,12 @@ use MailPoet\Settings\SettingsController;
use MailPoet\Settings\TrackingConfig;
use MailPoet\Statistics\Track\SubscriberActivityTracker;
use MailPoet\Statistics\Track\SubscriberCookie;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Util\Cookies;
use MailPoet\WooCommerce\Helper as WooCommerceHelper;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon;
use MailPoetVendor\Idiorm\ORM;
use PHPUnit\Framework\MockObject\MockObject;
use WC_Cart;
use WooCommerce;
@@ -279,13 +283,20 @@ class AbandonedCartTest extends \MailPoetTest {
$newsletter->status = Newsletter::STATUS_ACTIVE;
$newsletter->save();
$this->createNewsletterOptions($newsletter, [
'group' => WooCommerceEmail::SLUG,
'event' => AbandonedCart::SLUG,
'afterTimeType' => 'hours',
'afterTimeNumber' => self::SCHEDULE_EMAIL_AFTER_HOURS,
'sendTo' => 'user',
]);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterOptionFactory = new NewsletterOptionFactory();
$newsletterOptionFactory->createMultipleOptions(
$newsletterEntity,
[
'group' => WooCommerceEmail::SLUG,
'event' => AbandonedCart::SLUG,
'afterTimeType' => 'hours',
'afterTimeNumber' => self::SCHEDULE_EMAIL_AFTER_HOURS,
'sendTo' => 'user',
]
);
return $newsletter;
}
@@ -306,37 +317,6 @@ class AbandonedCartTest extends \MailPoetTest {
return $task;
}
private function createNewsletterOptions(Newsletter $newsletter, array $options) {
foreach ($options as $option => $value) {
$newsletterOptionField = NewsletterOptionField::where('name', $option)
->where('newsletter_type', $newsletter->type)
->findOne();
if (!$newsletterOptionField) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->hydrate([
'newsletter_type' => $newsletter->type,
'name' => $option,
]);
$newsletterOptionField->save();
}
$newsletterOption = NewsletterOption::where('newsletter_id', $newsletter->id)
->where('option_field_id', $newsletterOptionField->id)
->findOne();
if (!$newsletterOption) {
$newsletterOption = NewsletterOption::create();
$newsletterOption->hydrate([
'newsletter_id' => $newsletter->id,
'option_field_id' => $newsletterOptionField->id,
'value' => $value,
]);
$newsletterOption->save();
}
}
}
private function createSubscriber() {
$subscriber = Subscriber::create();
$subscriber->status = Subscriber::STATUS_SUBSCRIBED;
@@ -379,13 +359,13 @@ class AbandonedCartTest extends \MailPoetTest {
}
private function cleanup() {
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(ScheduledTaskSubscriberEntity::class);
$this->truncateEntity(SubscriberEntity::class);
}
public function _after() {

63
mailpoet/tests/integration/AutomaticEmails/WooCommerce/Events/FirstPurchaseTest.php
View File

@@ -7,19 +7,23 @@ use Codeception\Stub\Expected;
use Codeception\Util\Fixtures;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerce;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerceStubs\OrderDetails;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\ScheduledTaskSubscriber;
use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\Subscriber;
use MailPoet\Models\SubscriberSegment;
use MailPoet\Tasks\Sending;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\WooCommerce\Helper as WCHelper;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Idiorm\ORM;
require_once __DIR__ . '/../WooCommerceStubs/OrderDetails.php';
@@ -290,46 +294,23 @@ class FirstPurchaseTest extends \MailPoetTest {
}
public function _createNewsletterOption(array $options, $newsletterId) {
foreach ($options as $option => $value) {
$newsletterOptionField = NewsletterOptionField::where('name', $option)
->where('newsletter_type', Newsletter::TYPE_AUTOMATIC)
->findOne();
if (!$newsletterOptionField) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->hydrate(
[
'newsletter_type' => Newsletter::TYPE_AUTOMATIC,
'name' => $option,
]
);
$newsletterOptionField->save();
}
$newsletterOption = NewsletterOption::where('newsletter_id', $newsletterId)
->where('option_field_id', $newsletterOptionField->id)
->findOne();
if (!$newsletterOption) {
$newsletterOption = NewsletterOption::create();
$newsletterOption->hydrate(
[
'newsletter_id' => $newsletterId,
'option_field_id' => $newsletterOptionField->id,
'value' => $value,
]
);
$newsletterOption->save();
}
}
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletterId);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterOptionFactory = new NewsletterOptionFactory();
$newsletterOptionFactory->createMultipleOptions(
$newsletterEntity,
$options
);
}
public function _after() {
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(ScheduledTaskSubscriberEntity::class);
$this->truncateEntity(SubscriberEntity::class);
WPFunctions::set(new WPFunctions);
}
}

131
mailpoet/tests/integration/AutomaticEmails/WooCommerce/Events/PurchasedInCategoryTest.php
View File

@@ -4,19 +4,24 @@ namespace MailPoet\AutomaticEmails\WooCommerce\Events;
use Codeception\Util\Fixtures;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerce;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\ScheduledTaskSubscriber;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\Subscriber;
use MailPoet\Models\SubscriberSegment;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Tasks\Sending;
use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\WooCommerce\Helper as WCHelper;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Idiorm\ORM;
use PHPUnit\Framework\MockObject\MockObject;
class PurchasedInCategoryTest extends \MailPoetTest {
@@ -27,18 +32,26 @@ class PurchasedInCategoryTest extends \MailPoetTest {
/** @var PurchasedInCategory */
private $event;
/** @var NewsletterOptionsRepository */
private $newsletterOptionsRepository;
/** @var NewsletterOptionFieldsRepository */
private $newsletterOptionFieldsRepository;
public function _before() {
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(SubscriberEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(ScheduledTaskSubscriberEntity::class);
WPFunctions::set(new WPFunctions);
WPFunctions::get()->removeAllFilters('woocommerce_payment_complete');
$this->woocommerceHelper = $this->createMock(WCHelper::class);
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->newsletterOptionFieldsRepository = $this->diContainer->get(NewsletterOptionFieldsRepository::class);
$this->newsletterOptionsRepository = $this->diContainer->get(NewsletterOptionsRepository::class);
}
public function testItGetsEventDetails() {
@@ -85,7 +98,7 @@ class PurchasedInCategoryTest extends \MailPoetTest {
$this->_createSubscriber($customerEmail);
$this->event->scheduleEmail(3);
$scheduledTask = Sending::getByNewsletterId($newsletter->id);
$scheduledTask = Sending::getByNewsletterId($newsletter->getId());
$queue = $scheduledTask->queue();
// We only want to record the ID for the category that triggered the newsletter
expect($queue->getMeta())->equals(['orderedProductCategories' => ['15']]);
@@ -111,7 +124,7 @@ class PurchasedInCategoryTest extends \MailPoetTest {
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->event->scheduleEmail(3);
$queue1 = SendingQueue::where('newsletter_id', $newsletter->id)->findMany();
$queue1 = SendingQueue::where('newsletter_id', $newsletter->getId())->findMany();
expect($queue1)->notEmpty();
$order = $this->getOrderMock(['15', '17']);
@@ -126,7 +139,7 @@ class PurchasedInCategoryTest extends \MailPoetTest {
->will($this->returnValue($customerEmail));
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->event->scheduleEmail(4);
$queue2 = SendingQueue::where('newsletter_id', $newsletter->id)->findMany();
$queue2 = SendingQueue::where('newsletter_id', $newsletter->getId())->findMany();
expect($queue2)->count(count($queue1));
}
@@ -149,7 +162,7 @@ class PurchasedInCategoryTest extends \MailPoetTest {
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->event->scheduleEmail(3);
$queue1 = SendingQueue::where('newsletter_id', $newsletter->id)->findMany();
$queue1 = SendingQueue::where('newsletter_id', $newsletter->getId())->findMany();
expect($queue1)->notEmpty();
$order = $this->getOrderMock(['15']);
@@ -164,7 +177,7 @@ class PurchasedInCategoryTest extends \MailPoetTest {
->will($this->returnValue($customerEmail));
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->event->scheduleEmail(4);
$queue2 = SendingQueue::where('newsletter_id', $newsletter->id)->findMany();
$queue2 = SendingQueue::where('newsletter_id', $newsletter->getId())->findMany();
expect($queue1)->count(count($queue2));
}
@@ -187,10 +200,10 @@ class PurchasedInCategoryTest extends \MailPoetTest {
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->event->scheduleEmail(3);
$queue1 = SendingQueue::where('newsletter_id', $newsletter->id)->findMany();
$queue1 = SendingQueue::where('newsletter_id', $newsletter->getId())->findMany();
expect($queue1)->count(1);
$this->assertInstanceOf(Newsletter::class, $newsletter);
$this->assertInstanceOf(NewsletterEntity::class, $newsletter);
$this->updateEmailTriggerIds($newsletter, ['16']);
$order = $this->getOrderMock(['16']);
$this->woocommerceHelper = $this->createMock(WCHelper::class);
@@ -204,7 +217,7 @@ class PurchasedInCategoryTest extends \MailPoetTest {
->will($this->returnValue($customerEmail));
$this->event = new PurchasedInCategory($this->woocommerceHelper);
$this->event->scheduleEmail(4);
$queue2 = SendingQueue::where('newsletter_id', $newsletter->id)->findMany();
$queue2 = SendingQueue::where('newsletter_id', $newsletter->getId())->findMany();
expect($queue2)->count(2);
}
@@ -239,16 +252,17 @@ class PurchasedInCategoryTest extends \MailPoetTest {
return $orderMock;
}
private function _createNewsletter(): Newsletter {
$newsletter = Newsletter::createOrUpdate(
[
'subject' => 'WooCommerce',
'preheader' => 'preheader',
'type' => Newsletter::TYPE_AUTOMATIC,
'status' => Newsletter::STATUS_ACTIVE,
]
);
$this->_createNewsletterOption(
private function _createNewsletter(): NewsletterEntity {
$newsletterFactory = new NewsletterFactory();
$newsletter = $newsletterFactory
->withSubject('WooCommerce')
->withAutomaticType()
->withActiveStatus()
->create();
$newsletterOptionFactory = new NewsletterOptionFactory();
$newsletterOptionFactory->createMultipleOptions(
$newsletter,
[
'sendTo' => 'user',
'group' => WooCommerce::SLUG,
@@ -261,9 +275,9 @@ class PurchasedInCategoryTest extends \MailPoetTest {
['id' => '15'],
],
]),
],
$newsletter->id
]
);
return $newsletter;
}
@@ -284,45 +298,14 @@ class PurchasedInCategoryTest extends \MailPoetTest {
return $subscriber;
}
public function _createNewsletterOption(array $options, $newsletterId) {
foreach ($options as $option => $value) {
$newsletterOptionField = NewsletterOptionField::where('name', $option)
->where('newsletter_type', Newsletter::TYPE_AUTOMATIC)
->findOne();
if (!$newsletterOptionField) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->hydrate(
[
'newsletter_type' => Newsletter::TYPE_AUTOMATIC,
'name' => $option,
]
);
$newsletterOptionField->save();
}
private function updateEmailTriggerIds(NewsletterEntity $newsletter, array $triggerIds) {
$metaOptionField = $this->newsletterOptionFieldsRepository->findOneBy(['name' => 'meta']);
$this->assertInstanceOf(NewsletterOptionFieldEntity::class, $metaOptionField);
$newsletterOption = NewsletterOption::where('newsletter_id', $newsletterId)
->where('option_field_id', $newsletterOptionField->id)
->findOne();
if (!$newsletterOption) {
$newsletterOption = NewsletterOption::create();
$newsletterOption->hydrate(
[
'newsletter_id' => $newsletterId,
'option_field_id' => $newsletterOptionField->id,
'value' => $value,
]
);
$newsletterOption->save();
}
}
}
private function updateEmailTriggerIds(Newsletter $newsletter, array $triggerIds) {
$metaOptionField = NewsletterOptionField::where('name', 'meta')->findOne();
$this->assertInstanceOf(NewsletterOptionField::class, $metaOptionField);
$newsletterMetaOption = NewsletterOption::where(['newsletter_id' => $newsletter->id, 'option_field_id' => $metaOptionField->id])->findOne();
$this->assertInstanceOf(NewsletterOption::class, $newsletterMetaOption);
$optionValue = json_decode($newsletterMetaOption->value, true);
$newsletterMetaOption = $this->newsletterOptionsRepository->findOneBy(['newsletter' => $newsletter, 'optionField' => $metaOptionField]);
$this->assertInstanceOf(NewsletterOptionEntity::class, $newsletterMetaOption);
$this->assertIsString($newsletterMetaOption->getValue());
$optionValue = json_decode($newsletterMetaOption->getValue(), true);
$this->assertIsArray($optionValue);
$optionValue['option'] = [];
foreach ($triggerIds as $triggerId) {
@@ -330,7 +313,9 @@ class PurchasedInCategoryTest extends \MailPoetTest {
}
$newValue = json_encode($optionValue);
$this->assertIsString($newValue);
$newsletterMetaOption->set('value', $newValue);
$newsletterMetaOption->save();
$newsletterMetaOption->setValue($newValue);
$this->entityManager->persist($newsletterMetaOption);
$this->entityManager->flush($newsletterMetaOption);
}
}

97
mailpoet/tests/integration/AutomaticEmails/WooCommerce/Events/PurchasedProductTest.php
View File

@@ -8,26 +8,39 @@ use Codeception\Util\Fixtures;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerce;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerceStubs\ItemDetails;
use MailPoet\AutomaticEmails\WooCommerce\WooCommerceStubs\OrderDetails;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\ScheduledTaskSubscriber;
use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\Subscriber;
use MailPoet\Models\SubscriberSegment;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Tasks\Sending;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\WooCommerce\Helper as WCHelper;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Idiorm\ORM;
require_once __DIR__ . '/../WooCommerceStubs/ItemDetails.php';
require_once __DIR__ . '/../WooCommerceStubs/OrderDetails.php';
class PurchasedProductTest extends \MailPoetTest {
/** @var NewsletterOptionFieldsRepository */
private $newsletterOptionFieldsRepository;
/** @var NewsletterOptionsRepository */
private $newsletterOptionsRepository;
public function _before() {
WPFunctions::get()->removeAllFilters('woocommerce_payment_complete');
$this->newsletterOptionFieldsRepository = $this->diContainer->get(NewsletterOptionFieldsRepository::class);
$this->newsletterOptionsRepository = $this->diContainer->get(NewsletterOptionsRepository::class);
}
public function testItGetsEventDetails() {
@@ -246,53 +259,37 @@ class PurchasedProductTest extends \MailPoetTest {
}
private function updateEmailTriggerIds(Newsletter $newsletter, array $triggerIds) {
$metaOptionField = NewsletterOptionField::where('name', 'meta')->findOne();
$this->assertInstanceOf(NewsletterOptionField::class, $metaOptionField);
$newsletterMetaOption = NewsletterOption::where(['newsletter_id' => $newsletter->id, 'option_field_id' => $metaOptionField->id])->findOne();
$this->assertInstanceOf(NewsletterOption::class, $newsletterMetaOption);
$optionValue = json_decode($newsletterMetaOption->value, true);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$metaOptionField = $this->newsletterOptionFieldsRepository->findOneBy(['name' => 'meta']);
$this->assertInstanceOf(NewsletterOptionFieldEntity::class, $metaOptionField);
$newsletterMetaOption = $this->newsletterOptionsRepository->findOneBy(['newsletter' => $newsletterEntity, 'optionField' => $metaOptionField]);
$this->assertInstanceOf(NewsletterOptionEntity::class, $newsletterMetaOption);
$this->assertIsString($newsletterMetaOption->getValue());
$optionValue = json_decode($newsletterMetaOption->getValue(), true);
$this->assertIsArray($optionValue);
$optionValue['option'] = [];
foreach ($triggerIds as $triggerId) {
$optionValue['option'][] = ['id' => $triggerId];
}
$newValue = json_encode($optionValue);
$this->assertIsString($newValue);
$newsletterMetaOption->set('value', $newValue);
$newsletterMetaOption->save();
$newsletterMetaOption->setValue($newValue);
$this->entityManager->persist($newsletterMetaOption);
$this->entityManager->flush($newsletterMetaOption);
}
private function _createNewsletterOption(array $options, $newsletterId) {
foreach ($options as $option => $value) {
$newsletterOptionField = NewsletterOptionField::where('name', $option)
->where('newsletter_type', Newsletter::TYPE_AUTOMATIC)
->findOne();
if (!$newsletterOptionField) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->hydrate(
[
'newsletter_type' => Newsletter::TYPE_AUTOMATIC,
'name' => $option,
]
);
$newsletterOptionField->save();
}
$newsletterOption = NewsletterOption::where('newsletter_id', $newsletterId)
->where('option_field_id', $newsletterOptionField->id)
->findOne();
if (!$newsletterOption) {
$newsletterOption = NewsletterOption::create();
$newsletterOption->hydrate(
[
'newsletter_id' => $newsletterId,
'option_field_id' => $newsletterOptionField->id,
'value' => $value,
]
);
$newsletterOption->save();
}
}
public function _createNewsletterOption(array $options, $newsletterId) {
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletterId);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterOptionFactory = new NewsletterOptionFactory();
$newsletterOptionFactory->createMultipleOptions(
$newsletterEntity,
$options
);
}
private function createWooSubscriber(array $data = []) {
@@ -313,13 +310,13 @@ class PurchasedProductTest extends \MailPoetTest {
}
public function _after() {
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(ScheduledTaskSubscriberEntity::class);
$this->truncateEntity(SubscriberEntity::class);
WPFunctions::set(new WPFunctions);
}
}

198
mailpoet/tests/integration/Cron/Workers/SchedulerTest.php
View File

@@ -7,10 +7,19 @@ use Codeception\Stub\Expected;
use MailPoet\Cron\CronHelper;
use MailPoet\Cron\CronWorkerScheduler;
use MailPoet\Cron\Workers\Scheduler;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\NewsletterSegmentEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SegmentEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SettingEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Entities\SubscriberSegmentEntity;
use MailPoet\Logging\LoggerFactory;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\NewsletterSegment;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\ScheduledTaskSubscriber;
@@ -23,11 +32,10 @@ use MailPoet\Newsletter\Scheduler\WelcomeScheduler;
use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
use MailPoet\Segments\SegmentsRepository;
use MailPoet\Segments\SubscribersFinder;
use MailPoet\Settings\SettingsRepository;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon;
use MailPoetVendor\Idiorm\ORM;
use WP_User;
use MailPoet\Newsletter\Scheduler\Scheduler as NewsletterScheduler;
@@ -54,6 +62,9 @@ class SchedulerTest extends \MailPoetTest {
/** @var NewsletterScheduler */
private $newsletterScheduler;
/** @var NewsletterOptionFactory */
private $newsletterOptionFactory;
public function _before() {
parent::_before();
$this->loggerFactory = LoggerFactory::getInstance();
@@ -64,6 +75,7 @@ class SchedulerTest extends \MailPoetTest {
$this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
$this->segmentsRepository = $this->diContainer->get(SegmentsRepository::class);
$this->newsletterScheduler = $this->diContainer->get(NewsletterScheduler::class);
$this->newsletterOptionFactory = new NewsletterOptionFactory();
}
public function testItThrowsExceptionWhenExecutionLimitIsReached() {
@@ -126,9 +138,10 @@ class SchedulerTest extends \MailPoetTest {
public function testItCanDeleteQueueWhenDeliveryIsSetToImmediately() {
$newsletter = $this->_createNewsletter();
$newsletterOptionField =
$this->_createNewsletterOptionField('intervalType', Newsletter::TYPE_WELCOME);
$newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, 'immediately');
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'intervalType', 'immediately');
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -153,9 +166,10 @@ class SchedulerTest extends \MailPoetTest {
public function testItCanRescheduleQueueDeliveryTime() {
$newsletter = $this->_createNewsletter();
assert($newsletter instanceof Newsletter);
$newsletterOptionField =
$this->_createNewsletterOptionField('intervalType', Newsletter::TYPE_WELCOME);
$newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, 'daily');
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterOption = $this->newsletterOptionFactory->create($newsletterEntity, 'intervalType', 'daily');
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -174,8 +188,9 @@ class SchedulerTest extends \MailPoetTest {
// queue's next run date should change when interval type is set to anything
// other than "immediately"
$queue = $this->_createQueue($newsletter->id);
$newsletterOption->value = 'daily';
$newsletterOption->save();
$newsletterOption->setValue('daily');
$this->entityManager->persist($newsletterOption);
$this->entityManager->flush();
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
expect($queue->scheduledAt)->null();
@@ -191,14 +206,11 @@ class SchedulerTest extends \MailPoetTest {
$wPUser = $this->_createOrUpdateWPUser('editor');
$subscriber = $this->_createSubscriber();
$newsletter = $this->_createNewsletter(Newsletter::TYPE_WELCOME);
$newsletterOptionField = $this->_createNewsletterOptionField(
'role',
Newsletter::TYPE_WELCOME
);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id,
$newsletter->id, 'author'
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', 'author');
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -224,14 +236,11 @@ class SchedulerTest extends \MailPoetTest {
$wPUser = $this->_createOrUpdateWPUser('editor');
$subscriber = $this->_createSubscriber($wPUser->ID);
$newsletter = $this->_createNewsletter(Newsletter::TYPE_WELCOME);
$newsletterOptionField = $this->_createNewsletterOptionField(
'role',
Newsletter::TYPE_WELCOME
);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id,
$newsletter->id, 'author'
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', 'author');
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -258,12 +267,11 @@ class SchedulerTest extends \MailPoetTest {
$wPUser = $this->_createOrUpdateWPUser('author');
$subscriber = $this->_createSubscriber($wPUser->ID);
$newsletter = $this->_createNewsletter(Newsletter::TYPE_WELCOME);
$newsletterOptionField =
$this->_createNewsletterOptionField('role', Newsletter::TYPE_WELCOME);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id,
$newsletter->id, 'author'
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', 'author');
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -289,12 +297,11 @@ class SchedulerTest extends \MailPoetTest {
$wPUser = $this->_createOrUpdateWPUser('author');
$subscriber = $this->_createSubscriber($wPUser->ID);
$newsletter = $this->_createNewsletter(Newsletter::TYPE_WELCOME);
$newsletterOptionField =
$this->_createNewsletterOptionField('role', Newsletter::TYPE_WELCOME);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id, $newsletter->id,
WelcomeScheduler::WORDPRESS_ALL_ROLES
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'role', WelcomeScheduler::WORDPRESS_ALL_ROLES);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -429,8 +436,11 @@ class SchedulerTest extends \MailPoetTest {
$subscriber = $this->_createSubscriber();
$segment = $this->_createSegment();
$newsletter = $this->_createNewsletter();
$newsletterOptionField = $this->_createNewsletterOptionField('segment', Newsletter::TYPE_NOTIFICATION);
$newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, $segment->id);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -466,12 +476,11 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment();
$subscriberSegment = $this->_createSubscriberSegment($subscriber->id, $segment->id);
$newsletter = $this->_createNewsletter();
$newsletterOptionField =
$this->_createNewsletterOptionField('segment', Newsletter::TYPE_NOTIFICATION);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id, $newsletter->id,
$segment->id
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -507,12 +516,9 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment();
$subscriberSegment = $this->_createSubscriberSegment($subscriber->id, $segment->id);
$newsletter = $this->_createNewsletter();
$newsletterOptionField =
$this->_createNewsletterOptionField('segment', Newsletter::TYPE_NOTIFICATION);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id, $newsletter->id,
$segment->id
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -540,12 +546,9 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment();
$subscriberSegment = $this->_createSubscriberSegment($subscriber->id, $segment->id);
$newsletter = $this->_createNewsletter();
$newsletterOptionField =
$this->_createNewsletterOptionField('segment', Newsletter::TYPE_NOTIFICATION);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id, $newsletter->id,
$segment->id
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -572,12 +575,9 @@ class SchedulerTest extends \MailPoetTest {
$subscriberSegment = $this->_createSubscriberSegment($subscriber->id, $segment->id);
$newsletter = $this->_createNewsletter();
$newsletterSegment = $this->_createNewsletterSegment($newsletter->id, $segment->id);
$newsletterOptionField =
$this->_createNewsletterOptionField('segment', Newsletter::TYPE_NOTIFICATION);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id, $newsletter->id,
$segment->id
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -658,12 +658,9 @@ class SchedulerTest extends \MailPoetTest {
$newsletterSegment = $this->_createNewsletterSegment($newsletter->id, $segment->id);
$subscriber = $this->_createSubscriber();
$subscriberSegment = $this->_createSubscriberSegment($subscriber->id, $segment->id);
$newsletterOptionField =
$this->_createNewsletterOptionField('segment', Newsletter::TYPE_NOTIFICATION);
$newsletterOption = $this->_createNewsletterOption(
$newsletterOptionField->id, $newsletter->id,
$segment->id
);
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->create($newsletterEntity, 'segment', $segment->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
->findOne($newsletter->id);
assert($newsletter instanceof Newsletter);
@@ -943,11 +940,17 @@ class SchedulerTest extends \MailPoetTest {
$segment = $this->_createSegment();
$subscriber = $this->_createSubscriber();
$segmentSubscriber = $this->_createSubscriberSegment($subscriber->id, $segment->id);
$options = ['sendTo' => 'segment', 'segment' => $segment->id];
foreach ($options as $option => $value) {
$newsletterOptionField = $this->_createNewsletterOptionField($option, Newsletter::TYPE_AUTOMATIC);
$newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, $value);
}
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->newsletterOptionFactory->createMultipleOptions(
$newsletterEntity,
[
'sendTo' => 'segment',
'segment' => $segment->id
]
);
$task = SendingTask::create();
$task->newsletterId = $newsletter->id;
$task->status = SendingQueue::STATUS_SCHEDULED;
@@ -1051,25 +1054,6 @@ class SchedulerTest extends \MailPoetTest {
return $newsletter;
}
public function _createNewsletterOptionField($name, $type) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $name;
$newsletterOptionField->newsletterType = $type;
$newsletterOptionField->save();
expect($newsletterOptionField->getErrors())->false();
return $newsletterOptionField;
}
public function _createNewsletterOption($optionFieldId, $newsletterId, $value) {
$newsletterOption = NewsletterOption::create();
$newsletterOption->optionFieldId = $optionFieldId;
$newsletterOption->newsletterId = $newsletterId;
$newsletterOption->value = $value;
$newsletterOption->save();
expect($newsletterOption->getErrors())->false();
return $newsletterOption;
}
public function _createQueue($newsletterId, $status = SendingQueue::STATUS_SCHEDULED) {
$queue = SendingTask::create();
$queue->status = $status;
@@ -1105,16 +1089,16 @@ class SchedulerTest extends \MailPoetTest {
public function _after() {
Carbon::setTestNow();
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
$this->diContainer->get(SettingsRepository::class)->truncate();
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
ORM::raw_execute('TRUNCATE ' . SubscriberSegment::$_table);
ORM::raw_execute('TRUNCATE ' . Segment::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterSegment::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(SettingEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(ScheduledTaskSubscriberEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(SubscriberEntity::class);
$this->truncateEntity(SubscriberSegmentEntity::class);
$this->truncateEntity(SegmentEntity::class);
$this->truncateEntity(NewsletterSegmentEntity::class);
}
}

72
mailpoet/tests/integration/Models/NewsletterTest.php
View File

@@ -2,21 +2,26 @@
namespace MailPoet\Test\Models;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\NewsletterSegmentEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\SegmentEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\StatisticsClickEntity;
use MailPoet\Entities\StatisticsOpenEntity;
use MailPoet\Entities\StatisticsUnsubscribeEntity;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\NewsletterSegment;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Util\Security;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon;
use MailPoetVendor\Idiorm\ORM;
class NewsletterTest extends \MailPoetTest {
public $sendingQueue;
@@ -25,6 +30,9 @@ class NewsletterTest extends \MailPoetTest {
/** @var Newsletter */
public $newsletter;
/** @var NewsletterOptionFactory */
private $newsletterOptionFactory;
public function _before() {
parent::_before();
$this->newsletter = Newsletter::createOrUpdate([
@@ -53,6 +61,8 @@ class NewsletterTest extends \MailPoetTest {
$this->sendingQueue->newsletter_id = $this->newsletter->id;
$this->sendingQueue->status = ScheduledTask::STATUS_SCHEDULED;
$this->sendingQueue->save();
$this->newsletterOptionFactory = new NewsletterOptionFactory();
}
public function testItCanBeCreated() {
@@ -186,22 +196,14 @@ class NewsletterTest extends \MailPoetTest {
}
public function testItCanHaveOptions() {
$newsletterOptions = [
'name' => 'event',
'newsletter_type' => Newsletter::TYPE_WELCOME,
];
$optionField = NewsletterOptionField::create();
$optionField->hydrate($newsletterOptions);
$optionField->save();
$association = NewsletterOption::create();
$association->newsletterId = $this->newsletter->id;
$association->optionFieldId = (int)$optionField->id;
$association->value = 'list';
$association->save();
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $this->newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$newsletterOption = $this->newsletterOptionFactory->create($newsletterEntity, 'event', 'list');
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_STANDARD)
->findOne($this->newsletter->id);
assert($newsletter instanceof Newsletter);
expect($newsletter->event)->equals($association->value);
expect($newsletter->event)->equals($newsletterOption->getValue());
}
public function testItGeneratesHashOnNewsletterSave() {
@@ -446,24 +448,12 @@ class NewsletterTest extends \MailPoetTest {
'type' => Newsletter::TYPE_AUTOMATIC,
]
);
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->hydrate(
[
'newsletter_type' => Newsletter::TYPE_AUTOMATIC,
'name' => 'meta',
]
);
$newsletterOptionField->save();
$newsletterOption = NewsletterOption::create();
$meta = ['some' => 'value'];
$newsletterOption->hydrate(
[
'newsletter_id' => $newsletter->id,
'option_field_id' => $newsletterOptionField->id,
'value' => json_encode($meta),
]
);
$newsletterOption->save();
$newsletterEntity = $this->entityManager->getReference(NewsletterEntity::class, $newsletter->id);
$this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
$this->assertIsString(json_encode($meta));
$this->newsletterOptionFactory->create($newsletterEntity, 'meta', json_encode($meta));
// by default meta option does not exist on newsletter object
expect($newsletter->getMeta())->isEmpty();
@@ -532,13 +522,13 @@ class NewsletterTest extends \MailPoetTest {
}
public function _after() {
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
ORM::raw_execute('TRUNCATE ' . Segment::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterSegment::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(NewsletterSegmentEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(SegmentEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(StatisticsClickEntity::class);
$this->truncateEntity(StatisticsOpenEntity::class);
$this->truncateEntity(StatisticsUnsubscribeEntity::class);

138
mailpoet/tests/integration/Newsletter/Scheduler/AutomaticEmailTest.php
View File

@@ -3,40 +3,55 @@
namespace MailPoet\Newsletter\Scheduler;
use Codeception\Util\Fixtures;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\NewsletterOptionEntity;
use MailPoet\Entities\NewsletterOptionFieldEntity;
use MailPoet\Entities\NewsletterPostEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SubscriberEntity;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\ScheduledTask;
use MailPoet\Models\ScheduledTaskSubscriber;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\Subscriber;
use MailPoet\Tasks\Sending as SendingTask;
use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\WP\Functions as WPFunctions;
use MailPoetVendor\Carbon\Carbon;
use MailPoetVendor\Idiorm\ORM;
class AutomaticEmailTest extends \MailPoetTest {
/** @var AutomaticEmailScheduler */
private $automaticEmailScheduler;
/** @var NewsletterEntity */
private $newsletter;
/** @var NewsletterOptionFactory */
private $newsletterOptionFactory;
/** @var NewsletterFactory */
private $newsletterFactory;
public function _before() {
parent::_before();
$this->automaticEmailScheduler = $this->diContainer->get(AutomaticEmailScheduler::class);
}
public function testItCreatesScheduledAutomaticEmailSendingTaskForUser() {
$newsletter = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter->id,
$this->newsletterFactory = new NewsletterFactory();
$this->newsletter = $this->newsletterFactory->withActiveStatus()->withAutomaticType()->create();
$this->newsletterOptionFactory = new NewsletterOptionFactory();
$this->newsletterOptionFactory->createMultipleOptions(
$this->newsletter,
[
'sendTo' => 'user',
'afterTimeType' => 'hours',
'afterTimeNumber' => 2,
]
);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_AUTOMATIC)->findOne($newsletter->id);
}
public function testItCreatesScheduledAutomaticEmailSendingTaskForUser() {
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_AUTOMATIC)->findOne($this->newsletter->getId());
assert($newsletter instanceof Newsletter);
$subscriber = Subscriber::create();
$subscriber->hydrate(Fixtures::get('subscriber_template'));
@@ -59,16 +74,7 @@ class AutomaticEmailTest extends \MailPoetTest {
}
public function testItAddsMetaToSendingQueueWhenCreatingAutomaticEmailSendingTask() {
$newsletter = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter->id,
[
'sendTo' => 'user',
'afterTimeType' => 'hours',
'afterTimeNumber' => 2,
]
);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_AUTOMATIC)->findOne($newsletter->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_AUTOMATIC)->findOne($this->newsletter->getId());
assert($newsletter instanceof Newsletter);
$subscriber = Subscriber::create();
$subscriber->hydrate(Fixtures::get('subscriber_template'));
@@ -83,16 +89,7 @@ class AutomaticEmailTest extends \MailPoetTest {
}
public function testItCreatesAutomaticEmailSendingTaskForSegment() {
$newsletter = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter->id,
[
'sendTo' => 'segment',
'afterTimeType' => 'hours',
'afterTimeNumber' => 2,
]
);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_AUTOMATIC)->findOne($newsletter->id);
$newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_AUTOMATIC)->findOne($this->newsletter->getId());
assert($newsletter instanceof Newsletter);
$this->automaticEmailScheduler->createAutomaticEmailSendingTask($newsletter, $subscriber = null, $meta = null);
@@ -111,15 +108,11 @@ class AutomaticEmailTest extends \MailPoetTest {
}
public function testItDoesNotScheduleAutomaticEmailWhenGroupDoesNotMatch() {
$newsletter = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter->id,
$this->newsletterOptionFactory->createMultipleOptions(
$this->newsletter,
[
'group' => 'some_group',
'event' => 'some_event',
'sendTo' => 'user',
'afterTimeType' => 'hours',
'afterTimeNumber' => 2,
]
);
@@ -129,15 +122,11 @@ class AutomaticEmailTest extends \MailPoetTest {
}
public function testItDoesNotScheduleAutomaticEmailWhenEventDoesNotMatch() {
$newsletter = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter->id,
$this->newsletterOptionFactory->createMultipleOptions(
$this->newsletter,
[
'group' => 'some_group',
'event' => 'some_event',
'sendTo' => 'user',
'afterTimeType' => 'hours',
'afterTimeNumber' => 2,
]
);
@@ -148,20 +137,17 @@ class AutomaticEmailTest extends \MailPoetTest {
public function testItSchedulesAutomaticEmailWhenConditionMatches() {
$currentTime = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
$newsletter1 = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter1->id,
$this->newsletterOptionFactory->createMultipleOptions(
$this->newsletter,
[
'group' => 'some_group',
'event' => 'some_event',
'sendTo' => 'user',
'afterTimeType' => 'hours',
'afterTimeNumber' => 2,
]
);
$newsletter2 = $this->_createNewsletter();
$this->_createNewsletterOptions(
$newsletter2->id,
$newsletter2 = $this->newsletterFactory->withAutomaticType()->withActiveStatus()->create();
$this->newsletterOptionFactory->createMultipleOptions(
$newsletter2,
[
'group' => 'some_group',
'event' => 'some_event',
@@ -170,6 +156,7 @@ class AutomaticEmailTest extends \MailPoetTest {
'afterTimeNumber' => 2,
]
);
$condition = function($email) {
return $email->sendTo === 'segment';
};
@@ -183,7 +170,7 @@ class AutomaticEmailTest extends \MailPoetTest {
$automaticEmailScheduler->scheduleAutomaticEmail('some_group', 'some_event', $condition);
$result = SendingQueue::findMany();
expect($result)->count(1);
expect($result[0]->newsletter_id)->equals($newsletter2->id);
expect($result[0]->newsletter_id)->equals($newsletter2->getId());
// scheduled task should be created
$task = $result[0]->getTasks()->findOne();
expect($task->id)->greaterOrEquals(1);
@@ -193,44 +180,15 @@ class AutomaticEmailTest extends \MailPoetTest {
->equals($currentTime->addHours(2)->format('Y-m-d H:i'));
}
private function _createNewsletter() {
$newsletter = Newsletter::create();
$newsletter->type = Newsletter::TYPE_AUTOMATIC;
$newsletter->status = Newsletter::STATUS_ACTIVE;
$newsletter->save();
expect($newsletter->getErrors())->false();
return $newsletter;
}
private function _createNewsletterOptions($newsletterId, $options) {
foreach ($options as $option => $value) {
$newsletterOptionField = NewsletterOptionField::where('name', $option)->findOne();
if (!$newsletterOptionField) {
$newsletterOptionField = NewsletterOptionField::create();
$newsletterOptionField->name = $option;
$newsletterOptionField->newsletterType = Newsletter::TYPE_AUTOMATIC;
$newsletterOptionField->save();
expect($newsletterOptionField->getErrors())->false();
}
$newsletterOption = NewsletterOption::create();
$newsletterOption->optionFieldId = (int)$newsletterOptionField->id;
$newsletterOption->newsletterId = $newsletterId;
$newsletterOption->value = $value;
$newsletterOption->save();
expect($newsletterOption->getErrors())->false();
}
}
public function _after() {
Carbon::setTestNow();
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
$this->truncateEntity(NewsletterEntity::class);
$this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(NewsletterPostEntity::class);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table);
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table);
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table);
$this->truncateEntity(ScheduledTaskEntity::class);
$this->truncateEntity(ScheduledTaskSubscriberEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(SubscriberEntity::class);
}
}