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

Refactor InactiveSubscribersControllerTest to Doctrine

Browse Source 
[MAILPOET-3774]
This commit is contained in:
Jan Lysý
2021-09-22 16:51:59 +02:00
committed by Veljko V
parent ddb025c0ec
commit 8aad2a8126
1 changed files with 228 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

408
tests/integration/Subscribers/InactiveSubscribersControllerTest.php
View File

@@ -1,297 +1,345 @@
<?php <?php declare(strict_types = 1);
namespace MailPoet\Subscribers; namespace MailPoet\Subscribers;
use MailPoet\Config\MP2Migrator; use MailPoet\Config\MP2Migrator;
use MailPoet\Entities\NewsletterEntity;
use MailPoet\Entities\ScheduledTaskEntity;
use MailPoet\Entities\ScheduledTaskSubscriberEntity;
use MailPoet\Entities\SendingQueueEntity;
use MailPoet\Entities\SettingEntity; use MailPoet\Entities\SettingEntity;
use MailPoet\Models\Newsletter; use MailPoet\Entities\StatisticsOpenEntity;
use MailPoet\Models\ScheduledTask; use MailPoet\Entities\SubscriberEntity;
use MailPoet\Models\ScheduledTaskSubscriber;
use MailPoet\Models\SendingQueue;
use MailPoet\Models\StatisticsOpens;
use MailPoet\Models\Subscriber; use MailPoet\Models\Subscriber;
use MailPoet\Settings\SettingsRepository; use MailPoet\Settings\SettingsRepository;
use MailPoet\Tasks\Sending; use MailPoet\Tasks\Sending;
use MailPoetVendor\Carbon\Carbon; use MailPoetVendor\Carbon\Carbon;
use MailPoetVendor\Idiorm\ORM; use MailPoetVendor\Doctrine\ORM\EntityManager;
class InactiveSubscribersControllerTest extends \MailPoetTest { class InactiveSubscribersControllerTest extends \MailPoetTest {
/** @var InactiveSubscribersController */ /** @var InactiveSubscribersController */
private $controller; private $controller;
/** @var Newsletter */ /** @var SubscribersRepository */
private $subscribersRepository;
/** @var NewsletterEntity */
private $newsletter; private $newsletter;
const INACTIVITY_DAYS_THRESHOLD = 5; const INACTIVITY_DAYS_THRESHOLD = 5;
const PROCESS_BATCH_SIZE = 100; const PROCESS_BATCH_SIZE = 100;
public function _before() { public function _before() {
$this->controller = new InactiveSubscribersController($this->diContainer->get(SettingsRepository::class)); $this->controller = new InactiveSubscribersController(
ORM::raw_execute('TRUNCATE ' . Subscriber::$_table); $this->diContainer->get(EntityManager::class),
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table); $this->diContainer->get(SettingsRepository::class)
ORM::raw_execute('TRUNCATE ' . StatisticsOpens::$_table); );
ORM::raw_execute('TRUNCATE ' . ScheduledTaskSubscriber::$_table); $this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class);
ORM::raw_execute('TRUNCATE ' . SendingQueue::$_table); $this->truncateEntity(SubscriberEntity::class);
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table); $this->truncateEntity(ScheduledTaskEntity::class);
ORM::raw_execute('DROP TABLE IF EXISTS inactives_task_ids'); $this->truncateEntity(StatisticsOpenEntity::class);
$this->newsletter = Newsletter::createOrUpdate([ $this->truncateEntity(ScheduledTaskSubscriberEntity::class);
'subject' => "Subject ", $this->truncateEntity(SendingQueueEntity::class);
"type" => Newsletter::TYPE_STANDARD, $this->truncateEntity(NewsletterEntity::class);
"status" => Newsletter::STATUS_SENT, $this->entityManager->getConnection()->executeQuery('DROP TABLE IF EXISTS inactive_task_ids');
]); $this->newsletter = new NewsletterEntity();
$this->newsletter->save(); $this->newsletter->setSubject('Subject');
$this->newsletter->setType(NewsletterEntity::TYPE_STANDARD);
$this->newsletter->setStatus(NewsletterEntity::STATUS_SENT);
$this->entityManager->persist($this->newsletter);
$this->entityManager->flush();
parent::_before(); parent::_before();
} }
public function testItDeactivatesOldSubscribersWithUnopenedEmail() { public function testItDeactivatesOldSubscribersWithUnopenedEmail(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); [$task] = $this->createCompletedSendingTaskWithOneOpen(3);
$subscriber1 = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber1 = $this->createSubscriber('s1@email.com', 10);
$this->addSubcriberToTask($subscriber1, $task); $this->addSubscriberToTask($subscriber1, $task);
$subscriber2 = $this->createSubscriber('s2@email.com', $createdDaysAgo = 10); $subscriber2 = $this->createSubscriber('s2@email.com', 10);
$this->addSubcriberToTask($subscriber2, $task); $this->addSubscriberToTask($subscriber2, $task);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(2); expect($result)->equals(2);
$subscriber1 = Subscriber::findOne($subscriber1->id); $this->entityManager->clear();
$subscriber2 = Subscriber::findOne($subscriber2->id); $subscriber1 = $this->subscribersRepository->findOneById($subscriber1->getId());
expect($subscriber1->status)->equals(Subscriber::STATUS_INACTIVE); $subscriber2 = $this->subscribersRepository->findOneById($subscriber2->getId());
expect($subscriber2->status)->equals(Subscriber::STATUS_INACTIVE); assert($subscriber1 instanceof SubscriberEntity);
assert($subscriber2 instanceof SubscriberEntity);
expect($subscriber1->getStatus())->equals(SubscriberEntity::STATUS_INACTIVE);
expect($subscriber2->getStatus())->equals(SubscriberEntity::STATUS_INACTIVE);
} }
public function testItDeactivatesLimitedAmountOfSubscribers() { public function testItDeactivatesLimitedAmountOfSubscribers(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); [$task] = $this->createCompletedSendingTaskWithOneOpen(3);
$subscriber1 = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber1 = $this->createSubscriber('s1@email.com', 10);
$this->addSubcriberToTask($subscriber1, $task); $this->addSubscriberToTask($subscriber1, $task);
$subscriber2 = $this->createSubscriber('s2@email.com', $createdDaysAgo = 10); $subscriber2 = $this->createSubscriber('s2@email.com', 10);
$this->addSubcriberToTask($subscriber2, $task); $this->addSubscriberToTask($subscriber2, $task);
$batchSize = 1; $batchSize = 1;
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize, $subscriber1->id); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize, $subscriber1->getId());
$this->entityManager->clear();
expect($result)->equals(1); expect($result)->equals(1);
$subscriber1 = Subscriber::findOne($subscriber1->id); $subscriber1 = $this->subscribersRepository->findOneById($subscriber1->getId());
$subscriber2 = Subscriber::findOne($subscriber2->id); $subscriber2 = $this->subscribersRepository->findOneById($subscriber2->getId());
expect($subscriber1->status === Subscriber::STATUS_INACTIVE || $subscriber2->status === Subscriber::STATUS_INACTIVE)->true(); assert($subscriber1 instanceof SubscriberEntity);
expect($subscriber1->status === Subscriber::STATUS_SUBSCRIBED || $subscriber2->status === Subscriber::STATUS_SUBSCRIBED)->true(); assert($subscriber2 instanceof SubscriberEntity);
expect($subscriber1->getStatus() === SubscriberEntity::STATUS_INACTIVE || $subscriber2->getStatus() === SubscriberEntity::STATUS_INACTIVE)->true();
expect($subscriber1->getStatus() === SubscriberEntity::STATUS_SUBSCRIBED || $subscriber2->getStatus() === SubscriberEntity::STATUS_SUBSCRIBED)->true();
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize, $subscriber2->id); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize, $subscriber2->getId());
$this->entityManager->clear();
expect($result)->equals(1); expect($result)->equals(1);
$subscriber1 = Subscriber::findOne($subscriber1->id); $subscriber1 = $this->subscribersRepository->findOneById($subscriber1->getId());
$subscriber2 = Subscriber::findOne($subscriber2->id); $subscriber2 = $this->subscribersRepository->findOneById($subscriber2->getId());
expect($subscriber1->status)->equals(Subscriber::STATUS_INACTIVE); assert($subscriber1 instanceof SubscriberEntity);
expect($subscriber2->status)->equals(Subscriber::STATUS_INACTIVE); assert($subscriber2 instanceof SubscriberEntity);
expect($subscriber1->getStatus())->equals(SubscriberEntity::STATUS_INACTIVE);
expect($subscriber2->getStatus())->equals(SubscriberEntity::STATUS_INACTIVE);
} }
public function testItDoesNotDeactivateNewSubscriberWithUnopenedEmail() { public function testItDoesNotDeactivateNewSubscriberWithUnopenedEmail(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); [$task] = $this->createCompletedSendingTaskWithOneOpen(3);
$subscriber = $this->createSubscriber('s1@email.com', $completedDaysAgo = 3); $subscriber = $this->createSubscriber('s1@email.com', 3);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
public function testItDoesNotDeactivateNewlyResubscribedSubscriberWithUnopenedEmail() { public function testItDoesNotDeactivateNewlyResubscribedSubscriberWithUnopenedEmail(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); [$task] = $this->createCompletedSendingTaskWithOneOpen(3);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber = $this->createSubscriber('s1@email.com', 10);
$subscriber->lastSubscribedAt = (new Carbon())->subDays(2)->toDateTimeString(); $lastSubscribedAt = (new Carbon())->subDays(2);
$subscriber->save(); $subscriber->setLastSubscribedAt($lastSubscribedAt);
$this->addSubcriberToTask($subscriber, $task); $this->entityManager->flush();
$this->addSubscriberToTask($subscriber, $task);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
public function testItDoesNotDeactivateSubscriberWithoutSentEmail() { public function testItDoesNotDeactivateSubscriberWithoutSentEmail(): void {
$this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); $this->createCompletedSendingTaskWithOneOpen(3);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber = $this->createSubscriber('s1@email.com', 10);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
public function testItDoesNotDeactivateSubscriberWhoRecentlyOpenedEmail() { public function testItDoesNotDeactivateSubscriberWhoRecentlyOpenedEmail(): void {
list($task, $queue) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 2); [$task, $queue] = $this->createCompletedSendingTaskWithOneOpen(2);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber = $this->createSubscriber('s1@email.com', 10);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$this->addEmailOpenedRecord($subscriber, $queue, $openedDaysAgo = 2); $this->addEmailOpenedRecord($subscriber, $queue, 2);
list($task2) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 2); [$task2] = $this->createCompletedSendingTaskWithOneOpen(2);
$this->addSubcriberToTask($subscriber, $task2); $this->addSubscriberToTask($subscriber, $task2);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
public function testItDoesNotDeactivateSubscriberWhoReceivedEmailRecently() { public function testItDoesNotDeactivateSubscriberWhoReceivedEmailRecently(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 0); [$task] = $this->createCompletedSendingTaskWithOneOpen(0);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber = $this->createSubscriber('s1@email.com', 10);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
public function testItDoesNotDeactivatesSubscribersWhenMP2MigrationHappenedWithinInterval() { public function testItDoesNotDeactivatesSubscribersWhenMP2MigrationHappenedWithinInterval(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); [$task] = $this->createCompletedSendingTaskWithOneOpen(3);
$this->createSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY, true, (new Carbon())->subDays(3)); $this->createSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY, true, (new Carbon())->subDays(3));
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10); $subscriber = $this->createSubscriber('s1@email.com', 10);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markInactiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
$this->removeSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY); $this->removeSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY);
} }
public function testItActivatesSubscriberWhoRecentlyOpenedEmail() { public function testItActivatesSubscriberWhoRecentlyOpenedEmail(): void {
list($task, $queue) = $this->createCompletedSendingTask($completedDaysAgo = 2); [$task, $queue] = $this->createCompletedSendingTask(2);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10, Subscriber::STATUS_INACTIVE); $subscriber = $this->createSubscriber('s1@email.com', 10, SubscriberEntity::STATUS_INACTIVE);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$this->addEmailOpenedRecord($subscriber, $queue, $openedDaysAgo = 2); $this->addEmailOpenedRecord($subscriber, $queue, 2);
$result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
$this->entityManager->clear();
expect($result)->equals(1); expect($result)->equals(1);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
public function testItActivatesLimitedNumberOfSubscribers() { public function testItActivatesLimitedNumberOfSubscribers(): void {
list($task, $queue) = $this->createCompletedSendingTask($completedDaysAgo = 3); [$task, $queue] = $this->createCompletedSendingTask(3);
$subscriber1 = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10, Subscriber::STATUS_INACTIVE); $subscriber1 = $this->createSubscriber('s1@email.com', 10, SubscriberEntity::STATUS_INACTIVE);
$subscriber2 = $this->createSubscriber('s2@email.com', $createdDaysAgo = 10, Subscriber::STATUS_INACTIVE); $subscriber2 = $this->createSubscriber('s2@email.com', 10, SubscriberEntity::STATUS_INACTIVE);
$this->addSubcriberToTask($subscriber1, $task); $this->addSubscriberToTask($subscriber1, $task);
$this->addSubcriberToTask($subscriber2, $task); $this->addSubscriberToTask($subscriber2, $task);
$this->addEmailOpenedRecord($subscriber1, $queue, $openedDaysAgo = 2); $this->addEmailOpenedRecord($subscriber1, $queue, 2);
$this->addEmailOpenedRecord($subscriber2, $queue, $openedDaysAgo = 2); $this->addEmailOpenedRecord($subscriber2, $queue, 2);
$batchSize = 1; $batchSize = 1;
$result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize); $result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize);
$this->entityManager->clear();
expect($result)->equals(1); expect($result)->equals(1);
$subscriber1 = Subscriber::findOne($subscriber1->id); $subscriber1 = $this->subscribersRepository->findOneById($subscriber1->getId());
$subscriber2 = Subscriber::findOne($subscriber2->id); $subscriber2 = $this->subscribersRepository->findOneById($subscriber2->getId());
expect($subscriber1->status === Subscriber::STATUS_INACTIVE || $subscriber2->status === Subscriber::STATUS_INACTIVE)->true(); assert($subscriber1 instanceof SubscriberEntity);
expect($subscriber1->status === Subscriber::STATUS_SUBSCRIBED || $subscriber2->status === Subscriber::STATUS_SUBSCRIBED)->true(); assert($subscriber2 instanceof SubscriberEntity);
expect($subscriber1->getStatus() === Subscriber::STATUS_INACTIVE || $subscriber2->getStatus() === Subscriber::STATUS_INACTIVE)->true();
expect($subscriber1->getStatus() === Subscriber::STATUS_SUBSCRIBED || $subscriber2->getStatus() === Subscriber::STATUS_SUBSCRIBED)->true();
$result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize); $result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, $batchSize);
$this->entityManager->clear();
expect($result)->equals(1); expect($result)->equals(1);
$subscriber1 = Subscriber::findOne($subscriber1->id); $subscriber1 = $this->subscribersRepository->findOneById($subscriber1->getId());
$subscriber2 = Subscriber::findOne($subscriber2->id); $subscriber2 = $this->subscribersRepository->findOneById($subscriber2->getId());
expect($subscriber1->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber1 instanceof SubscriberEntity);
expect($subscriber2->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber2 instanceof SubscriberEntity);
expect($subscriber1->getStatus())->equals(Subscriber::STATUS_SUBSCRIBED);
expect($subscriber2->getStatus())->equals(Subscriber::STATUS_SUBSCRIBED);
} }
public function testItDoesNotActivateOldSubscribersWithUnopenedEmail() { public function testItDoesNotActivateOldSubscribersWithUnopenedEmail(): void {
list($task) = $this->createCompletedSendingTask($completedDaysAgo = 2); [$task] = $this->createCompletedSendingTask(2);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10, Subscriber::STATUS_INACTIVE); $subscriber = $this->createSubscriber('s1@email.com', 10, SubscriberEntity::STATUS_INACTIVE);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
$this->entityManager->clear();
expect($result)->equals(0); expect($result)->equals(0);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_INACTIVE); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_INACTIVE);
} }
public function testItActivatesSubscribersWhenMP2MigrationHappenedWithinInterval() { public function testItActivatesSubscribersWhenMP2MigrationHappenedWithinInterval(): void {
list($task) = $this->createCompletedSendingTaskWithOneOpen($completedDaysAgo = 3); [$task] = $this->createCompletedSendingTaskWithOneOpen(3);
$this->createSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY, true, (new Carbon())->subDays(3)); $this->createSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY, true, (new Carbon())->subDays(3));
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10, Subscriber::STATUS_INACTIVE); $subscriber = $this->createSubscriber('s1@email.com', 10, SubscriberEntity::STATUS_INACTIVE);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE); $result = $this->controller->markActiveSubscribers(self::INACTIVITY_DAYS_THRESHOLD, self::PROCESS_BATCH_SIZE);
$this->entityManager->clear();
expect($result)->equals(1); expect($result)->equals(1);
$subscriber = Subscriber::findOne($subscriber->id); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
$this->removeSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY); $this->removeSetting(MP2Migrator::MIGRATION_COMPLETE_SETTING_KEY);
} }
public function testItDoesReactivateInactiveSubscribers() { public function testItDoesReactivateInactiveSubscribers(): void {
list($task) = $this->createCompletedSendingTask($completedDaysAgo = 2); [$task] = $this->createCompletedSendingTask(2);
$subscriber = $this->createSubscriber('s1@email.com', $createdDaysAgo = 10, Subscriber::STATUS_INACTIVE); $subscriber = $this->createSubscriber('s1@email.com', 10, SubscriberEntity::STATUS_INACTIVE);
$this->addSubcriberToTask($subscriber, $task); $this->addSubscriberToTask($subscriber, $task);
$this->controller->reactivateInactiveSubscribers(); $this->controller->reactivateInactiveSubscribers();
$subscriber = Subscriber::findOne($subscriber->id); $this->entityManager->clear();
expect($subscriber->status)->equals(Subscriber::STATUS_SUBSCRIBED); $subscriber = $this->subscribersRepository->findOneById($subscriber->getId());
assert($subscriber instanceof SubscriberEntity);
expect($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
} }
/** private function createSubscriber(
* @param string $email string $email,
* @param int $createdDaysAgo int $createdDaysAgo = 0,
* @param string $status string $status = Subscriber::STATUS_SUBSCRIBED
* @return Subscriber ): SubscriberEntity {
*/ $createdAt = (new Carbon())->subDays($createdDaysAgo);
private function createSubscriber($email, $createdDaysAgo = 0, $status = Subscriber::STATUS_SUBSCRIBED) { $subscriber = new SubscriberEntity();
$createdAt = (new Carbon())->subDays($createdDaysAgo)->toDateTimeString(); $subscriber->setEmail($email);
$subscriber = Subscriber::createOrUpdate(['email' => $email, 'status' => $status]); $subscriber->setStatus($status);
$subscriber->createdAt = $createdAt; $subscriber->setCreatedAt($createdAt);
$subscriber->lastSubscribedAt = $createdAt; $this->entityManager->persist($subscriber);
$subscriber->save(); // we need to set lastSubscribeAt after persist due to LastSubscribedAtListener
$subscriber->setLastSubscribedAt($createdAt);
$this->entityManager->flush();
return $subscriber; return $subscriber;
} }
/** private function createCompletedSendingTask(int $processedDaysAgo = 0): array {
* @param int $processedDaysAgo $processedAt = (new Carbon())->subDays($processedDaysAgo);
* @return array $task = new ScheduledTaskEntity();
*/ $task->setType(Sending::TASK_TYPE);
private function createCompletedSendingTask($processedDaysAgo = 0) { $task->setStatus(ScheduledTaskEntity::STATUS_COMPLETED);
$processedAt = (new Carbon())->subDays($processedDaysAgo)->toDateTimeString(); $task->setCreatedAt($processedAt);
$task = ScheduledTask::createOrUpdate(['type' => Sending::TASK_TYPE, 'status' => ScheduledTask::STATUS_COMPLETED]); $task->setProcessedAt($processedAt);
$task->createdAt = $processedAt; $this->entityManager->persist($task);
$task->processedAt = $processedAt; $this->entityManager->flush();
$task->save(); $queue = new SendingQueueEntity();
$queue = SendingQueue::createOrUpdate(['task_id' => $task->id, 'newsletter_id' => $this->newsletter->id]); $queue->setTask($task);
$queue->save(); $queue->setNewsletter($this->newsletter);
$this->entityManager->persist($queue);
$this->entityManager->flush();
return [$task, $queue]; return [$task, $queue];
} }
/** private function createCompletedSendingTaskWithOneOpen(int $processedDaysAgo = 0): array {
* @param int $processedDaysAgo [$task, $queue] = $this->createCompletedSendingTask($processedDaysAgo);
* @return array $subscriber = $this->subscribersRepository->findOneBy(['email' => 's0@email.com']);
*/ if (!$subscriber) {
private function createCompletedSendingTaskWithOneOpen($processedDaysAgo = 0) { $subscriber = $this->createSubscriber('s0@email.com', 10);
list($task, $queue) = $this->createCompletedSendingTask($processedDaysAgo); }
$subscriber0 = $this->createSubscriber('s0@email.com', $createdDaysAgo = 10); $this->addSubscriberToTask($subscriber, $task);
$this->addSubcriberToTask($subscriber0, $task); $this->addEmailOpenedRecord($subscriber, $queue);
$this->addEmailOpenedRecord($subscriber0, $queue);
return [$task, $queue]; return [$task, $queue];
} }
/** private function addSubscriberToTask(
* @param Subscriber $subscriber SubscriberEntity $subscriber,
* @param ScheduledTask $task ScheduledTaskEntity $task,
* @param int $daysAgo int $daysAgo = 0
*/ ): ScheduledTaskSubscriberEntity {
private function addSubcriberToTask(Subscriber $subscriber, ScheduledTask $task, $daysAgo = 0) { $createdAt = (new Carbon())->subDays($daysAgo);
$createdAt = (new Carbon())->subDays($daysAgo)->toDateTimeString(); $taskSubscriber = new ScheduledTaskSubscriberEntity($task, $subscriber);
$taskSubscriber = ScheduledTaskSubscriber::createOrUpdate(['task_id' => $task->id, 'subscriber_id' => $subscriber->id]); $taskSubscriber->setCreatedAt($createdAt);
$taskSubscriber->createdAt = $createdAt; $this->entityManager->persist($taskSubscriber);
$taskSubscriber->save(); $this->entityManager->flush();
return $taskSubscriber;
} }
private function addEmailOpenedRecord(Subscriber $subscriber, SendingQueue $queue, $daysAgo = 0) { private function addEmailOpenedRecord(
$opened = StatisticsOpens::createOrUpdate(['subscriber_id' => $subscriber->id, 'newsletter_id' => $queue->newsletterId, 'queue_id' => $queue->id]); SubscriberEntity $subscriber,
$opened->createdAt = (new Carbon())->subDays($daysAgo)->toDateTimeString(); SendingQueueEntity $queue,
$opened->save(); int $daysAgo = 0
$subscriber->lastEngagementAt = (new Carbon())->subDays($daysAgo)->toDateTimeString(); ): StatisticsOpenEntity {
$subscriber->save(); $createdAt = (new Carbon())->subDays($daysAgo);
$opened = new StatisticsOpenEntity($this->newsletter, $queue, $subscriber);
$opened->setCreatedAt($createdAt);
$subscriber->setLastEngagementAt($createdAt);
$this->entityManager->persist($opened);
$this->entityManager->flush();
return $opened;
} }
private function createSetting($name, $value, $createdAt) { private function createSetting($name, $value, $createdAt) {
$tableName = $this->entityManager->getClassMetadata(SettingEntity::class)->getTableName(); $tableName = $this->entityManager->getClassMetadata(SettingEntity::class)->getTableName();
$this->connection->executeUpdate( $this->connection->executeStatement(
"INSERT INTO $tableName (name, value, created_at) VALUES (?, ?, ?)", "INSERT INTO $tableName (name, value, created_at) VALUES (?, ?, ?)",
[$name, $value, $createdAt] [$name, $value, $createdAt]
); );
@@ -299,6 +347,6 @@ class InactiveSubscribersControllerTest extends \MailPoetTest {
private function removeSetting($name) { private function removeSetting($name) {
$tableName = $this->entityManager->getClassMetadata(SettingEntity::class)->getTableName(); $tableName = $this->entityManager->getClassMetadata(SettingEntity::class)->getTableName();
$this->connection->executeUpdate("DELETE FROM $tableName WHERE name = ?", [$name]); $this->connection->executeStatement("DELETE FROM $tableName WHERE name = ?", [$name]);
} }
} }