Refactor save controller tests, use Doctrine

[MAILPOET-2900]

tasks/phpstan/phpstan-baseline-integration-tests.neon

@@ -47,22 +47,12 @@ parameters:
 
 		-
 			message: "#^Cannot call method withSegments\\(\\) on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
-			count: 2
+			count: 1
 			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
 
 		-
 			message: "#^Cannot call method asArray\\(\\) on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
-			count: 8
+			count: 6
-			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
-
-		-
-			message: "#^Cannot access property \\$someOption on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
-			count: 1
-			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
-
-		-
-			message: "#^Cannot access property \\$unsubscribeToken on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
-			count: 1
 			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
 
 		-
@@ -70,26 +60,11 @@ parameters:
 			count: 1
 			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
 
-		-
-			message: "#^Cannot call method asArray\\(\\) on MailPoet\\\\Models\\\\SendingQueue\\|false\\.$#"
-			count: 2
-			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
-
-		-
-			message: "#^Cannot access property \\$schedule on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
-			count: 1
-			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
-
 		-
 			message: "#^Cannot access property \\$deletedAt on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
 			count: 1
 			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
 
-		-
-			message: "#^Cannot access property \\$status on MailPoet\\\\Models\\\\Newsletter\\|false\\.$#"
-			count: 1
-			path: ../../tests/integration/API/JSON/v1/NewslettersTest.php
-
 		-
 			message: "#^Cannot call method asArray\\(\\) on MailPoet\\\\Models\\\\Segment\\|false\\.$#"
 			count: 5

tests/integration/Newsletter/NewsletterSaveControllerTest.php

@@ -3,55 +3,34 @@
 namespace MailPoet\Newsletter;
 
 use Codeception\Util\Fixtures;
+use MailPoet\Entities\NewsletterEntity;
 use MailPoet\Entities\NewsletterOptionEntity;
-use MailPoet\Models\Newsletter;
+use MailPoet\Entities\NewsletterOptionFieldEntity;
-use MailPoet\Models\NewsletterOptionField;
+use MailPoet\Entities\NewsletterSegmentEntity;
-use MailPoet\Models\Segment;
+use MailPoet\Entities\ScheduledTaskEntity;
-use MailPoet\Models\SendingQueue;
+use MailPoet\Entities\SegmentEntity;
+use MailPoet\Entities\SendingQueueEntity;
 use MailPoet\Newsletter\Scheduler\PostNotificationScheduler;
 use MailPoet\Newsletter\Scheduler\Scheduler;
+use MailPoet\Newsletter\Sending\SendingQueuesRepository;
 use MailPoet\Settings\SettingsController;
 use MailPoet\Tasks\Sending as SendingTask;
 use MailPoetVendor\Carbon\Carbon;
 
 class NewsletterSaveControllerTest extends \MailPoetTest {
-  /** @var Newsletter */
-  private $newsletter;
-
-  /** @var Newsletter */
-  private $postNotification;
-
   /** @var NewsletterSaveController */
   private $saveController;
 
   public function _before() {
     parent::_before();
+    $this->cleanup();
     $this->saveController = $this->diContainer->get(NewsletterSaveController::class);
-    $this->newsletter = Newsletter::createOrUpdate([
-      'subject' => 'My Standard Newsletter',
-      'body' => Fixtures::get('newsletter_body_template'),
-      'type' => Newsletter::TYPE_STANDARD,
-    ]);
-
-    $this->postNotification = Newsletter::createOrUpdate([
-      'subject' => 'My Post Notification',
-      'body' => Fixtures::get('newsletter_body_template'),
-      'type' => Newsletter::TYPE_NOTIFICATION,
-    ]);
-
-    NewsletterOptionField::createOrUpdate([
-      'name' => 'isScheduled',
-      'newsletter_type' => 'standard',
-    ]);
-    NewsletterOptionField::createOrUpdate([
-      'name' => 'scheduledAt',
-      'newsletter_type' => 'standard',
-    ]);
   }
 
   public function testItCanSaveANewsletter() {
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
     $newsletterData = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
       'subject' => 'Updated subject',
     ];
 
@@ -60,89 +39,47 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
   }
 
   public function testItDoesNotRerenderPostNotificationsUponUpdate() {
-    // create newsletter options
+    $this->createPostNotificationOptions();
-    $newsletterOptions = [
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_NOTIFICATION);
-      'intervalType',
+    $this->createQueueWithTask($newsletter);
-      'timeOfDay',
-      'weekDay',
-      'monthDay',
-      'nthWeekDay',
-      'schedule',
-    ];
-    foreach ($newsletterOptions as $option) {
-      $newsletterOptionField = NewsletterOptionField::create();
-      $newsletterOptionField->name = $option;
-      $newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
-      $newsletterOptionField->save();
-    }
-
-    $sendingQueue = SendingTask::create();
-    $sendingQueue->newsletterId = $this->postNotification->id;
-    $sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
-    $sendingQueue->newsletterRenderedBody = null;
-    $sendingQueue->newsletterRenderedSubject = null;
-    $sendingQueue->save();
-    expect($sendingQueue->getErrors())->false();
 
     $newsletterData = [
-      'id' => $this->postNotification->id,
+      'id' => $newsletter->getId(),
       'subject' => 'My Updated Newsletter',
       'body' => Fixtures::get('newsletter_body_template'),
     ];
 
     $newsletter = $this->saveController->save($newsletterData);
-    $updatedQueue = SendingQueue::where('newsletter_id', $this->postNotification->id)
+    $updatedQueue = $newsletter->getLatestQueue();
-      ->findOne()
+    assert($updatedQueue instanceof SendingQueueEntity); // PHPStan
-      ->asArray();
+    expect($updatedQueue->getNewsletterRenderedSubject())->null();
-
+    expect($updatedQueue->getNewsletterRenderedBody())->null();
-    expect($updatedQueue['newsletter_rendered_body'])->null();
-    expect($updatedQueue['newsletter_rendered_subject'])->null();
   }
 
   public function testItCanRerenderQueueUponSave() {
-    $sendingQueue = SendingTask::create();
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
-    $sendingQueue->newsletterId = $this->newsletter->id;
+    $this->createQueueWithTask($newsletter);
-    $sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
-    $sendingQueue->newsletterRenderedBody = null;
-    $sendingQueue->newsletterRenderedSubject = null;
-    $sendingQueue->save();
-    expect($sendingQueue->getErrors())->false();
 
     $newsletterData = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
       'subject' => 'My Updated Newsletter',
       'body' => Fixtures::get('newsletter_body_template'),
     ];
 
-    $newsletter = $this->saveController->save($newsletterData);
+    $this->saveController->save($newsletterData);
-    $updatedQueue = SendingQueue::where('newsletter_id', $this->newsletter->id)
+    $updatedQueue = $newsletter->getLatestQueue();
-      ->findOne()
+    assert($updatedQueue instanceof SendingQueueEntity); // PHPStan
-      ->asArray();
+    expect($updatedQueue->getNewsletterRenderedSubject())->same('My Updated Newsletter');
-
+    expect($updatedQueue->getNewsletterRenderedBody())->hasKey('html');
-    expect($updatedQueue['newsletter_rendered_body'])->hasKey('html');
+    expect($updatedQueue->getNewsletterRenderedBody())->hasKey('text');
-    expect($updatedQueue['newsletter_rendered_body'])->hasKey('text');
-    expect($updatedQueue['newsletter_rendered_subject'])->equals('My Updated Newsletter');
   }
 
   public function testItCanUpdatePostNotificationScheduleUponSave() {
-    $newsletterOptions = [
+    $this->createPostNotificationOptions();
-      'intervalType',
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
-      'timeOfDay',
-      'weekDay',
-      'monthDay',
-      'nthWeekDay',
-      'schedule',
-    ];
-    foreach ($newsletterOptions as $option) {
-      $newsletterOptionField = NewsletterOptionField::create();
-      $newsletterOptionField->name = $option;
-      $newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
-      $newsletterOptionField->save();
-    }
-
     $newsletterData = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
-      'type' => Newsletter::TYPE_NOTIFICATION,
+      'type' => NewsletterEntity::TYPE_NOTIFICATION,
       'subject' => 'Newsletter',
       'options' => [
         'intervalType' => PostNotificationScheduler::INTERVAL_WEEKLY,
@@ -155,7 +92,8 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
     ];
     $newsletter = $this->saveController->save($newsletterData);
     $scheduleOption = $newsletter->getOptions()->filter(function (NewsletterOptionEntity $newsletterOption) {
-      return $newsletterOption->getOptionField()->getName() === 'schedule';
+      $optionField = $newsletterOption->getOptionField();
+      return $optionField && $optionField->getName() === 'schedule';
     })->first();
 
     expect($scheduleOption->getValue())->equals('0 14 * * 1');
@@ -165,45 +103,34 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
     $savedNewsletter = $this->saveController->save($newsletterData);
 
     $scheduleOption = $savedNewsletter->getOptions()->filter(function (NewsletterOptionEntity $newsletterOption) {
-      return $newsletterOption->getOptionField()->getName() === 'schedule';
+      $optionField = $newsletterOption->getOptionField();
+      return $optionField && $optionField->getName() === 'schedule';
     })->first();
 
     expect($scheduleOption->getValue())->equals('* * * * *');
   }
 
   public function testItCanReschedulePreviouslyScheduledSendingQueueJobs() {
-    // create newsletter options
+    $this->createPostNotificationOptions();
-    $newsletterOptions = [
+
-      'intervalType',
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_NOTIFICATION);
-      'timeOfDay',
-      'weekDay',
-      'monthDay',
-      'nthWeekDay',
-      'schedule',
-    ];
-    foreach ($newsletterOptions as $option) {
-      $newsletterOptionField = NewsletterOptionField::create();
-      $newsletterOptionField->name = $option;
-      $newsletterOptionField->newsletterType = Newsletter::TYPE_NOTIFICATION;
-      $newsletterOptionField->save();
-    }
 
-    // create sending queues
     $currentTime = Carbon::now();
-    $sendingQueue1 = SendingTask::create();
+    $queue1 = $this->createQueueWithTask($newsletter);
-    $sendingQueue1->newsletterId = 1;
+    $task1 = $queue1->getTask();
-    $sendingQueue1->status = SendingQueue::STATUS_SCHEDULED;
+    assert($task1 instanceof ScheduledTaskEntity); // PHPStan
-    $sendingQueue1->scheduledAt = $currentTime;
+    $task1->setScheduledAt($currentTime);
-    $sendingQueue1->save();
 
-    $sendingQueue2 = SendingTask::create();
+    $queue2 = $this->createQueueWithTask($newsletter);
-    $sendingQueue2->newsletterId = 1;
+    $task2 = $queue2->getTask();
-    $sendingQueue2->save();
+    assert($task2 instanceof ScheduledTaskEntity); // PHPStan
+    $task2->setStatus(null);
+
+    $this->entityManager->flush();
 
-    // save newsletter via router
     $newsletterData = [
-      'id' => 1,
+      'id' => $newsletter->getId(),
-      'type' => Newsletter::TYPE_NOTIFICATION,
+      'type' => NewsletterEntity::TYPE_NOTIFICATION,
       'subject' => 'Newsletter',
       'options' => [
         // weekly on Monday @ 7am
@@ -215,34 +142,32 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
         'schedule' => '0 7 * * 1',
       ],
     ];
+
     $newsletter = $this->saveController->save($newsletterData);
-    /** @var SendingQueue $sendingQueue1 */
-    $sendingQueue1 = SendingQueue::findOne($sendingQueue1->id);
-    $sendingQueue1 = SendingTask::createFromQueue($sendingQueue1);
-    /** @var SendingQueue $sendingQueue2 */
-    $sendingQueue2 = SendingQueue::findOne($sendingQueue2->id);
-    $sendingQueue2 = SendingTask::createFromQueue($sendingQueue2);
-    expect($sendingQueue1->scheduledAt)->notEquals($currentTime);
-
     $scheduleOption = $newsletter->getOptions()->filter(function (NewsletterOptionEntity $newsletterOption) {
-      return $newsletterOption->getOptionField()->getName() === 'schedule';
+      $optionField = $newsletterOption->getOptionField();
+      return $optionField && $optionField->getName() === 'schedule';
     })->first();
-
+    expect($task1->getScheduledAt())->notEquals($currentTime);
-    expect($sendingQueue1->scheduledAt)->equals(
+    expect($task1->getScheduledAt())->equals(Scheduler::getNextRunDate($scheduleOption->getValue()));
-      Scheduler::getNextRunDate($scheduleOption->getValue())
+    expect($task2->getScheduledAt())->null();
-    );
-    expect($sendingQueue2->scheduledAt)->null();
   }
 
   public function testItCanModifySegmentsOfExistingNewsletter() {
-    $segment1 = Segment::createOrUpdate(['name' => 'Segment 1']);
+    $segment = new SegmentEntity();
+    $segment->setType(SegmentEntity::TYPE_DEFAULT);
+    $segment->setName('Segment 1');
+    $segment->setDescription('Segment 1 description');
+    $this->entityManager->persist($segment);
+    $this->entityManager->flush();
     $fakeSegmentId = 1;
 
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
     $newsletterData = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
       'subject' => 'My Updated Newsletter',
       'segments' => [
-        $segment1->asArray(),
+        ['id' => $segment->getId()],
         $fakeSegmentId,
       ],
     ];
@@ -253,43 +178,41 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
   }
 
   public function testItDeletesSendingQueueAndSetsNewsletterStatusToDraftWhenItIsUnscheduled() {
-    $newsletter = $this->newsletter;
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_SCHEDULED);
-    $newsletter->status = Newsletter::STATUS_SCHEDULED;
-    $newsletter->save();
-    expect($newsletter->getErrors())->false();
 
-    $sendingQueue = SendingTask::create();
+    $queue = $this->createQueueWithTask($newsletter);
-    $sendingQueue->newsletterId = $newsletter->id;
+    $queue->setNewsletterRenderedBody([
-    $sendingQueue->newsletterRenderedBody = [
       'html' => 'html',
       'text' => 'text',
-    ];
+    ]);
-    $sendingQueue->status = SendingQueue::STATUS_SCHEDULED;
+    $task = $queue->getTask();
-    $sendingQueue->scheduledAt = Carbon::now()->format('Y-m-d H:i');
+    assert($task instanceof ScheduledTaskEntity); // PHPStan
-    $sendingQueue->save();
+    $task->setScheduledAt(Carbon::now());
-    expect($sendingQueue->getErrors())->false();
+    $this->entityManager->flush();
+    $queueId = $queue->getId();
 
     $newsletterData = [
-      'id' => $newsletter->id,
+      'id' => $newsletter->getId(),
       'options' => [
         'isScheduled' => false,
       ],
     ];
 
     $newsletter = $this->saveController->save($newsletterData);
-    $sendingQueue = SendingQueue::findOne($sendingQueue->id);
+    expect($newsletter->getStatus())->equals(NewsletterEntity::STATUS_DRAFT);
-    expect($newsletter->getStatus())->equals(Newsletter::STATUS_DRAFT);
+    expect($newsletter->getLatestQueue())->null();
-    expect($sendingQueue)->false();
+    expect($this->diContainer->get(SendingQueuesRepository::class)->findOneById($queueId))->null();
   }
 
   public function testItSavesDefaultSenderIfNeeded() {
     $settings = $this->diContainer->get(SettingsController::class);
     $settings->set('sender', null);
 
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
     $data = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
       'subject' => 'My New Newsletter',
-      'type' => Newsletter::TYPE_STANDARD,
+      'type' => NewsletterEntity::TYPE_STANDARD,
       'sender_name' => 'Test sender',
       'sender_address' => 'test@example.com',
     ];
@@ -303,10 +226,11 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
     $settings = $this->diContainer->get(SettingsController::class);
     $settings->set('sender', null);
 
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
     $data = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
       'subject' => 'My New Newsletter',
-      'type' => Newsletter::TYPE_STANDARD,
+      'type' => NewsletterEntity::TYPE_STANDARD,
       'sender_name' => '',
       'sender_address' => null,
     ];
@@ -322,10 +246,11 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
       'address' => 'test@example.com',
     ]);
 
+    $newsletter = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD);
     $data = [
-      'id' => $this->newsletter->id,
+      'id' => $newsletter->getId(),
       'subject' => 'My New Newsletter',
-      'type' => Newsletter::TYPE_STANDARD,
+      'type' => NewsletterEntity::TYPE_STANDARD,
       'sender_name' => 'Another test sender',
       'sender_address' => 'another.test@example.com',
     ];
@@ -334,4 +259,64 @@ class NewsletterSaveControllerTest extends \MailPoetTest {
     expect($settings->get('sender.name'))->same('Test sender');
     expect($settings->get('sender.address'))->same('test@example.com');
   }
+
+  public function _after() {
+    $this->cleanup();
+  }
+
+  private function createNewsletter(string $type, string $status = NewsletterEntity::STATUS_DRAFT): NewsletterEntity {
+    $newsletter = new NewsletterEntity();
+    $newsletter->setType($type);
+    $newsletter->setSubject('My Standard Newsletter');
+    $newsletter->setBody(Fixtures::get('newsletter_body_template'));
+    $newsletter->setStatus($status);
+    $this->entityManager->persist($newsletter);
+    $this->entityManager->flush();
+    return $newsletter;
+  }
+
+  private function createQueueWithTask(NewsletterEntity $newsletter): SendingQueueEntity {
+    $task = new ScheduledTaskEntity();
+    $task->setType(SendingTask::TASK_TYPE);
+    $task->setStatus(ScheduledTaskEntity::STATUS_SCHEDULED);
+    $this->entityManager->persist($task);
+
+    $queue = new SendingQueueEntity();
+    $queue->setNewsletter($newsletter);
+    $queue->setTask($task);
+    $this->entityManager->persist($queue);
+
+    $newsletter->getQueues()->add($queue);
+    $this->entityManager->flush();
+    return $queue;
+  }
+
+  private function createPostNotificationOptions() {
+    $newsletterOptions = [
+      'intervalType',
+      'timeOfDay',
+      'weekDay',
+      'monthDay',
+      'nthWeekDay',
+      'schedule',
+    ];
+
+    foreach ($newsletterOptions as $optionName) {
+      $newsletterOptionField = new NewsletterOptionFieldEntity();
+      $newsletterOptionField->setNewsletterType(NewsletterEntity::TYPE_NOTIFICATION);
+      $newsletterOptionField->setName($optionName);
+      $this->entityManager->persist($newsletterOptionField);
+    }
+    $this->entityManager->flush();
+  }
+
+  private function cleanup() {
+    $this->truncateEntity(NewsletterEntity::class);
+    $this->truncateEntity(NewsletterSegmentEntity::class);
+    $this->truncateEntity(NewsletterOptionEntity::class);
+    $this->truncateEntity(NewsletterOptionFieldEntity::class);
+    $this->truncateEntity(ScheduledTaskEntity::class);
+    $this->truncateEntity(SendingQueueEntity::class);
+    $this->truncateEntity(SegmentEntity::class);
+  }
 }