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

Refactor test to doctrine

Browse Source 
[MAILPOET-3876]
This commit is contained in:
Pavel Dohnal
2021-11-03 13:38:17 +01:00
committed by Veljko V
parent 5da71f7a28
commit f5614ed2bd
1 changed files with 71 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
tests/integration/API/JSON/v1/SendingQueueTest.php
View File

@ -7,32 +7,36 @@ use Codeception\Util\Stub;
use MailPoet\API\JSON\Response as APIResponse; use MailPoet\API\JSON\Response as APIResponse;
use MailPoet\API\JSON\v1\SendingQueue as SendingQueueAPI; use MailPoet\API\JSON\v1\SendingQueue as SendingQueueAPI;
use MailPoet\Entities\NewsletterEntity; 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\SendingQueueEntity;
use MailPoet\Models\SendingQueue as SendingQueueModel;
use MailPoet\Newsletter\NewslettersRepository; use MailPoet\Newsletter\NewslettersRepository;
use MailPoet\Newsletter\Options\NewsletterOptionFieldsRepository;
use MailPoet\Newsletter\Options\NewsletterOptionsRepository;
use MailPoet\Newsletter\Sending\ScheduledTasksRepository;
use MailPoet\Segments\SubscribersFinder; use MailPoet\Segments\SubscribersFinder;
use MailPoet\Services\Bridge; use MailPoet\Services\Bridge;
use MailPoet\Settings\SettingsController; use MailPoet\Settings\SettingsController;
use MailPoet\Settings\SettingsRepository; use MailPoet\Settings\SettingsRepository;
use MailPoet\Tasks\Sending; use MailPoet\Tasks\Sending;
use MailPoet\Util\License\Features\Subscribers as SubscribersFeature; use MailPoet\Util\License\Features\Subscribers as SubscribersFeature;
use MailPoetVendor\Idiorm\ORM;
class SendingQueueTest extends \MailPoetTest { class SendingQueueTest extends \MailPoetTest {
public $newsletter; /** @var NewsletterEntity */
private $newsletter;
public function _before() { public function _before() {
parent::_before(); parent::_before();
$this->newsletter = Newsletter::createOrUpdate( $this->clean();
[
'subject' => 'My Standard Newsletter', $this->newsletter = new NewsletterEntity();
'body' => Fixtures::get('newsletter_body_template'), $this->newsletter->setSubject('My Standard Newsletter');
'type' => Newsletter::TYPE_STANDARD, $this->newsletter->setBody(json_decode(Fixtures::get('newsletter_body_template'), true));
] $this->newsletter->setType(NewsletterEntity::TYPE_STANDARD);
); $this->entityManager->persist($this->newsletter);
$this->entityManager->flush();
$settings = SettingsController::getInstance(); $settings = SettingsController::getInstance();
$settings->set('sender', [ $settings->set('sender', [
'name' => 'John Doe', 'name' => 'John Doe',
@ -42,25 +46,26 @@ class SendingQueueTest extends \MailPoetTest {
public function testItCreatesNewScheduledSendingQueueTask() { public function testItCreatesNewScheduledSendingQueueTask() {
$newsletter = $this->newsletter; $newsletter = $this->newsletter;
$newsletter->status = Newsletter::STATUS_SCHEDULED; $newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED);
$newsletter->save(); $this->entityManager->flush();
$newletterOptions = [ $newletterOptions = [
'isScheduled' => 1, 'isScheduled' => 1,
'scheduledAt' => '2018-10-10 10:00:00', 'scheduledAt' => '2018-10-10 10:00:00',
]; ];
$this->_createOrUpdateNewsletterOptions( $this->_createOrUpdateNewsletterOptions(
$newsletter->id, $newsletter,
Newsletter::TYPE_STANDARD, NewsletterEntity::TYPE_STANDARD,
$newletterOptions $newletterOptions
); );
$sendingQueue = $this->diContainer->get(SendingQueueAPI::class); $sendingQueue = $this->diContainer->get(SendingQueueAPI::class);
$result = $sendingQueue->add(['newsletter_id' => $newsletter->id]); $result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]);
$scheduledTask = ScheduledTask::findOne($result->data['task_id']); $repo = $this->diContainer->get(ScheduledTasksRepository::class);
assert($scheduledTask instanceof ScheduledTask); $scheduledTask = $repo->findOneById($result->data['task_id']);
expect($scheduledTask->status)->equals(ScheduledTask::STATUS_SCHEDULED); assert($scheduledTask instanceof ScheduledTaskEntity);
expect($scheduledTask->scheduledAt)->equals($newletterOptions['scheduledAt']); expect($scheduledTask->getStatus())->equals(ScheduledTaskEntity::STATUS_SCHEDULED);
expect($scheduledTask->type)->equals(Sending::TASK_TYPE); expect($scheduledTask->getScheduledAt()->format('Y-m-d H:i:s'))->equals($newletterOptions['scheduledAt']);
expect($scheduledTask->getType())->equals(Sending::TASK_TYPE);
} }
public function testItReturnsErrorIfSubscribersLimitReached() { public function testItReturnsErrorIfSubscribersLimitReached() {
@ -72,49 +77,52 @@ class SendingQueueTest extends \MailPoetTest {
$this->diContainer->get(Bridge::class), $this->diContainer->get(Bridge::class),
$this->diContainer->get(SubscribersFinder::class) $this->diContainer->get(SubscribersFinder::class)
); );
$res = $sendingQueue->add(['newsletter_id' => $this->newsletter->id]); $res = $sendingQueue->add(['newsletter_id' => $this->newsletter->getId()]);
expect($res->status)->equals(APIResponse::STATUS_FORBIDDEN); expect($res->status)->equals(APIResponse::STATUS_FORBIDDEN);
$res = $sendingQueue->resume(['newsletter_id' => $this->newsletter->id]); $res = $sendingQueue->resume(['newsletter_id' => $this->newsletter->getId()]);
expect($res->status)->equals(APIResponse::STATUS_FORBIDDEN); expect($res->status)->equals(APIResponse::STATUS_FORBIDDEN);
} }
public function testItReschedulesScheduledSendingQueueTask() { public function testItReschedulesScheduledSendingQueueTask() {
$newsletter = $this->newsletter; $newsletter = $this->newsletter;
$newsletter->status = Newsletter::STATUS_SCHEDULED; $newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED);
$newsletter->save(); $this->entityManager->flush();
$newletterOptions = [ $newletterOptions = [
'isScheduled' => 1, 'isScheduled' => 1,
'scheduledAt' => '2018-10-10 10:00:00', 'scheduledAt' => '2018-10-10 10:00:00',
]; ];
$this->_createOrUpdateNewsletterOptions( $this->_createOrUpdateNewsletterOptions(
$newsletter->id, $newsletter,
Newsletter::TYPE_STANDARD, NewsletterEntity::TYPE_STANDARD,
$newletterOptions $newletterOptions
); );
$sendingQueue = $this->diContainer->get(SendingQueueAPI::class); $sendingQueue = $this->diContainer->get(SendingQueueAPI::class);
// add scheduled task // add scheduled task
$result = $sendingQueue->add(['newsletter_id' => $newsletter->id]); $result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]);
$scheduledTask = ScheduledTask::findOne($result->data['task_id']); $repo = $this->diContainer->get(ScheduledTasksRepository::class);
assert($scheduledTask instanceof ScheduledTask); $scheduledTask = $repo->findOneById($result->data['task_id']);
expect($scheduledTask->scheduledAt)->equals('2018-10-10 10:00:00'); assert($scheduledTask instanceof ScheduledTaskEntity);
expect($scheduledTask->getScheduledAt()->format('Y-m-d H:i:s'))->equals('2018-10-10 10:00:00');
// update scheduled time // update scheduled time
$newletterOptions = [ $newletterOptions = [
'scheduledAt' => '2018-11-11 11:00:00', 'scheduledAt' => '2018-11-11 11:00:00',
]; ];
$this->_createOrUpdateNewsletterOptions( $this->_createOrUpdateNewsletterOptions(
$newsletter->id, $newsletter,
Newsletter::TYPE_STANDARD, NewsletterEntity::TYPE_STANDARD,
$newletterOptions $newletterOptions
); );
$result = $sendingQueue->add(['newsletter_id' => $newsletter->id]); $result = $sendingQueue->add(['newsletter_id' => $newsletter->getId()]);
$rescheduledTask = ScheduledTask::findOne($result->data['task_id']); $repo = $this->diContainer->get(ScheduledTasksRepository::class);
assert($rescheduledTask instanceof ScheduledTask); $this->entityManager->clear();
$rescheduledTask = $repo->findOneById($result->data['task_id']);
assert($rescheduledTask instanceof ScheduledTaskEntity);
// new task was not created // new task was not created
expect($rescheduledTask->id)->equals($scheduledTask->id); expect($rescheduledTask->getId())->equals($scheduledTask->getId());
// scheduled time was updated // scheduled time was updated
expect($rescheduledTask->scheduledAt)->equals('2018-11-11 11:00:00'); expect($rescheduledTask->getScheduledAt()->format('Y-m-d H:i:s'))->equals('2018-11-11 11:00:00');
} }
public function testItRejectsNewsletterWithoutUnsubscribeLink() { public function testItRejectsNewsletterWithoutUnsubscribeLink() {
@ -139,37 +147,35 @@ class SendingQueueTest extends \MailPoetTest {
expect($response['errors'][0]['error'])->stringContainsString('bad_request'); expect($response['errors'][0]['error'])->stringContainsString('bad_request');
} }
private function _createOrUpdateNewsletterOptions($newsletterId, $newsletterType, $options) { private function _createOrUpdateNewsletterOptions(NewsletterEntity $newsletter, $newsletterType, $options) {
$newsletterOptionFieldRepository = $this->diContainer->get(NewsletterOptionFieldsRepository::class);
$newsletterOptionRepository = $this->diContainer->get(NewsletterOptionsRepository::class);
foreach ($options as $option => $value) { foreach ($options as $option => $value) {
$newsletterOptionField = NewsletterOptionField::where('name', $option)->findOne(); $newsletterOptionField = $newsletterOptionFieldRepository->findOneBy(['name' => $option]);
if (!$newsletterOptionField) { if (!$newsletterOptionField instanceof NewsletterOptionFieldEntity) {
$newsletterOptionField = NewsletterOptionField::create(); $newsletterOptionField = new NewsletterOptionFieldEntity();
$newsletterOptionField->name = $option; $newsletterOptionField->setName($option);
$newsletterOptionField->newsletterType = $newsletterType; $newsletterOptionField->setNewsletterType($newsletterType);
$newsletterOptionField->save(); $this->entityManager->persist($newsletterOptionField);
expect($newsletterOptionField->getErrors())->false();
} }
$newsletterOption = NewsletterOption::where('newsletter_id', $newsletterId) $newsletterOption = $newsletterOptionRepository->findOneBy(['newsletter' => $newsletter, 'optionField' => $newsletterOptionField]);
->where('option_field_id', $newsletterOptionField->id) if (!$newsletterOption instanceof NewsletterOptionEntity) {
->findOne(); $newsletterOption = new NewsletterOptionEntity($newsletter, $newsletterOptionField);
if (!$newsletterOption) { $this->entityManager->persist($newsletterOption);
$newsletterOption = NewsletterOption::create();
$newsletterOption->optionFieldId = (int)$newsletterOptionField->id;
$newsletterOption->newsletterId = $newsletterId;
} }
$newsletterOption->value = $value; $newsletterOption->setValue($value);
$newsletterOption->save();
expect($newsletterOption->getErrors())->false();
} }
$this->entityManager->flush();
} }
public function _after() { public function clean() {
ORM::raw_execute('TRUNCATE ' . Newsletter::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOption::$_table);
ORM::raw_execute('TRUNCATE ' . NewsletterOptionField::$_table);
$this->diContainer->get(SettingsRepository::class)->truncate(); $this->diContainer->get(SettingsRepository::class)->truncate();
ORM::raw_execute('TRUNCATE ' . SendingQueueModel::$_table); $this->truncateEntity(NewsletterEntity::class);
ORM::raw_execute('TRUNCATE ' . ScheduledTask::$_table); $this->truncateEntity(NewsletterOptionEntity::class);
$this->truncateEntity(NewsletterOptionFieldEntity::class);
$this->truncateEntity(SendingQueueEntity::class);
$this->truncateEntity(ScheduledTaskEntity::class);
} }
} }