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

Revert "Replace NewsletterOption and NewsletterOptionField models"

Browse Source 
This reverts commit 9b087f719f.
This commit is contained in:
David Remer
2022-05-17 12:23:30 +03:00
committed by Veljko V
parent 46ebe847be
commit fce14358bf
8 changed files with 478 additions and 343 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,6 +24,9 @@ use MailPoet\Entities\SubscriberSegmentEntity;
use MailPoet\Form\Util\FieldNameObfuscator; use MailPoet\Form\Util\FieldNameObfuscator;
use MailPoet\Listing\Handler; use MailPoet\Listing\Handler;
use MailPoet\Models\CustomField; use MailPoet\Models\CustomField;
use MailPoet\Models\Newsletter;
use MailPoet\Models\NewsletterOption;
use MailPoet\Models\NewsletterOptionField;
use MailPoet\Models\Segment; use MailPoet\Models\Segment;
use MailPoet\Models\SendingQueue; use MailPoet\Models\SendingQueue;
use MailPoet\Models\Subscriber; use MailPoet\Models\Subscriber;
@@ -40,8 +43,6 @@ use MailPoet\Subscribers\SubscriberSubscribeController;
use MailPoet\Subscription\Captcha; use MailPoet\Subscription\Captcha;
use MailPoet\Subscription\CaptchaSession; use MailPoet\Subscription\CaptchaSession;
use MailPoet\Test\DataFactories\DynamicSegment; use MailPoet\Test\DataFactories\DynamicSegment;
use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
use MailPoet\Test\DataFactories\NewsletterOption as NewsletterOptionFactory;
use MailPoet\UnexpectedValueException; use MailPoet\UnexpectedValueException;
use MailPoet\WP\Functions; use MailPoet\WP\Functions;
use MailPoetVendor\Carbon\Carbon; use MailPoetVendor\Carbon\Carbon;
@@ -987,23 +988,32 @@ class SubscribersTest extends \MailPoetTest {
} }
private function _createWelcomeNewsletter() { private function _createWelcomeNewsletter() {
$newsletterFactory = new NewsletterFactory(); $welcomeNewsletter = Newsletter::create();
$welcomeNewsletter = $newsletterFactory $welcomeNewsletter->type = Newsletter::TYPE_WELCOME;
->withActiveStatus() $welcomeNewsletter->status = Newsletter::STATUS_ACTIVE;
->create(); $welcomeNewsletter->save();
$welcomeNewsletter->setType(NewsletterEntity::TYPE_WELCOME); expect($welcomeNewsletter->getErrors())->false();
$this->entityManager->persist($welcomeNewsletter);
$this->entityManager->flush();
$newsletterOptionFactory = new NewsletterOptionFactory(); $welcomeNewsletterOptions = [
$newsletterOptionFactory->createMultipleOptions( 'event' => 'segment',
$welcomeNewsletter, 'segment' => $this->segment1->getId(),
[ 'schedule' => '* * * * *',
'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();
}
} }
public function _after() { public function _after() {

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

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

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

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

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

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

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

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

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

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

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

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

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

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