Replace Newsletter model with NewsletterEntity in SendingQueue

This was the easiest way to fix failing integration tests related to
updating some Sending methods to use Doctrine instead of Paris. Using
Paris in SendingQueue to update the database was creating a state where
Doctrine had stale data and this was causing the tests to fail.

[MAILPOET-4368]

mailpoet/lib/API/JSON/v1/SendingQueue.php

@@ -13,7 +13,6 @@ use MailPoet\Entities\NewsletterEntity;
 use MailPoet\Entities\ScheduledTaskEntity;
 use MailPoet\Entities\SendingQueueEntity;
 use MailPoet\Mailer\MailerFactory;
-use MailPoet\Models\Newsletter;
 use MailPoet\Models\SendingQueue as SendingQueueModel;
 use MailPoet\Newsletter\NewslettersRepository;
 use MailPoet\Newsletter\NewsletterValidator;
@@ -96,21 +95,16 @@ class SendingQueue extends APIEndpoint {
     );
 
     // check that the newsletter exists
-    $newsletter = Newsletter::findOneWithOptions($newsletterId);
+    $newsletter = $this->newsletterRepository->findOneById($newsletterId);
+    $this->newsletterRepository->prefetchOptions([$newsletter]);
 
-    if (!$newsletter instanceof Newsletter) {
+    if (!$newsletter instanceof NewsletterEntity) {
-      return $this->errorResponse([
-        APIError::NOT_FOUND => __('This newsletter does not exist.', 'mailpoet'),
-      ]);
-    }
-    $newsletterEntity = $this->newsletterRepository->findOneById($newsletterId);
-    if (!$newsletterEntity instanceof NewsletterEntity) {
       return $this->errorResponse([
         APIError::NOT_FOUND => __('This newsletter does not exist.', 'mailpoet'),
       ]);
     }
 
-    $validationError = $this->newsletterValidator->validate($newsletterEntity);
+    $validationError = $this->newsletterValidator->validate($newsletter);
     if ($validationError) {
       return $this->errorResponse([
         APIError::BAD_REQUEST => $validationError,
@@ -128,7 +122,7 @@ class SendingQueue extends APIEndpoint {
 
     // add newsletter to the sending queue
     $queue = SendingQueueModel::joinWithTasks()
-      ->where('queues.newsletter_id', $newsletterEntity->getId())
+      ->where('queues.newsletter_id', $newsletter->getId())
       ->whereNull('tasks.status')
       ->findOne();
 
@@ -139,31 +133,31 @@ class SendingQueue extends APIEndpoint {
     }
 
     $scheduledQueue = SendingQueueModel::joinWithTasks()
-      ->where('queues.newsletter_id', $newsletterEntity->getId())
+      ->where('queues.newsletter_id', $newsletter->getId())
       ->where('tasks.status', SendingQueueModel::STATUS_SCHEDULED)
       ->findOne();
     if ($scheduledQueue instanceof SendingQueueModel) {
       $queue = SendingTask::createFromQueue($scheduledQueue);
     } else {
       $queue = SendingTask::create();
-      $queue->newsletterId = $newsletterEntity->getId();
+      $queue->newsletterId = $newsletter->getId();
     }
 
     WordPress::resetRunInterval();
-    if ((bool)$newsletterEntity->getOptionValue('isScheduled')) {
+    if ((bool)$newsletter->getOptionValue('isScheduled')) {
       // set newsletter status
-      $newsletterEntity->setStatus(NewsletterEntity::STATUS_SCHEDULED);
+      $newsletter->setStatus(NewsletterEntity::STATUS_SCHEDULED);
 
       // set queue status
       $queue->status = SendingQueueModel::STATUS_SCHEDULED;
-      $queue->scheduledAt = $this->scheduler->formatDatetimeString($newsletterEntity->getOptionValue('scheduledAt'));
+      $queue->scheduledAt = $this->scheduler->formatDatetimeString($newsletter->getOptionValue('scheduledAt'));
     } else {
-      $segments = $newsletterEntity->getSegmentIds();
+      $segments = $newsletter->getSegmentIds();
       $taskModel = $queue->task();
       $taskEntity = $this->scheduledTasksRepository->findOneById($taskModel->id);
 
       if ($taskEntity instanceof ScheduledTaskEntity) {
-        $subscribersCount = $this->subscribersFinder->addSubscribersToTaskFromSegments($taskEntity, $segments, $newsletterEntity->getFilterSegmentId());
+        $subscribersCount = $this->subscribersFinder->addSubscribersToTaskFromSegments($taskEntity, $segments, $newsletter->getFilterSegmentId());
       }
 
       if (!isset($subscribersCount) || !$subscribersCount) {
@@ -176,7 +170,7 @@ class SendingQueue extends APIEndpoint {
       $queue->scheduledAt = null;
 
       // set newsletter status
-      $newsletterEntity->setStatus(Newsletter::STATUS_SENDING);
+      $newsletter->setStatus(NewsletterEntity::STATUS_SENDING);
     }
     $queue->save();
     $this->newsletterRepository->flush();
@@ -185,9 +179,9 @@ class SendingQueue extends APIEndpoint {
     if (!empty($errors)) {
       return $this->errorResponse($errors);
     } else {
-      $this->triggerSending($newsletterEntity);
+      $this->triggerSending($newsletter);
       return $this->successResponse(
-        $newsletter->getQueue()->asArray()
+        ($newsletter->getLatestQueue() instanceof SendingQueueEntity) ? $newsletter->getLatestQueue()->toArray() : null
       );
     }
   }

mailpoet/lib/Entities/SendingQueueEntity.php

@@ -223,4 +223,36 @@ class SendingQueueEntity {
   public function setNewsletter(NewsletterEntity $newsletter) {
     $this->newsletter = $newsletter;
   }
+
+  public function toArray(): array {
+    if (!$this->getTask() instanceof ScheduledTaskEntity) {
+      throw new \RuntimeException('Invalid state. SendingQueue has ScheduledTask associated.');
+    }
+
+    return [
+      'id' => $this->getId(),
+      'type' => $this->getTask()->getType(),
+      'status' => $this->getTask()->getStatus(),
+      'priority' => $this->getTask()->getPriority(),
+      'scheduled_at' => $this->getFormattedDateOrNull($this->getTask()->getScheduledAt()),
+      'processed_at' => $this->getFormattedDateOrNull($this->getTask()->getProcessedAt()),
+      'created_at' => $this->getFormattedDateOrNull($this->getTask()->getCreatedAt()),
+      'updated_at' => $this->getFormattedDateOrNull($this->getTask()->getUpdatedAt()),
+      'deleted_at' => $this->getFormattedDateOrNull($this->getTask()->getDeletedAt()),
+      'in_progress' => $this->getTask()->getInProgress(),
+      'reschedule_count' => $this->getTask()->getRescheduleCount(),
+      'meta' => $this->getMeta(),
+      'task_id' => $this->getTask()->getId(),
+      'newsletter_id' => ($this->getNewsletter() instanceof NewsletterEntity) ? $this->getNewsletter()->getId() : null,
+      'newsletter_rendered_body' => $this->getNewsletterRenderedBody(),
+      'newsletter_rendered_subject' => $this->getNewsletterRenderedSubject(),
+      'count_total' => $this->getCountTotal(),
+      'count_processed' => $this->getCountProcessed(),
+      'count_to_process' => $this->getCountToProcess(),
+    ];
+  }
+
+  private function getFormattedDateOrNull(?\DateTimeInterface $date): ?string {
+    return $date ? $date->format('Y-m-d H:i:s') : null;
+  }
 }

mailpoet/tests/integration/Entities/SendingQueueEntityTest.php

@@ -0,0 +1,61 @@
+<?php declare(strict_types = 1);
+
+namespace integration\Entities;
+
+use MailPoet\Entities\NewsletterEntity;
+use MailPoet\Entities\ScheduledTaskEntity;
+use MailPoet\Entities\SendingQueueEntity;
+use MailPoet\Tasks\Sending;
+use MailPoet\Test\DataFactories\Newsletter as NewsletterFactory;
+use MailPoet\Test\DataFactories\ScheduledTask as ScheduledTaskFactory;
+use MailPoet\Test\DataFactories\SendingQueue as SendingQueueFactory;
+use MailPoetVendor\Carbon\Carbon;
+
+class SendingQueueEntityTest extends \MailPoetTest {
+  /** @var NewsletterEntity */
+  private $newsletter;
+
+  /** @var ScheduledTaskEntity */
+  private $scheduledTask;
+
+  /** @var SendingQueueEntity */
+  private $sendingQueue;
+
+  public function _before() {
+    $newsletterFactory = new NewsletterFactory();
+    $sendingQueueFactory = new SendingQueueFactory();
+    $scheduledTaskFactory = new ScheduledTaskFactory();
+
+    $scheduledAt = new Carbon('2018-10-10 10:00:00');
+    $this->newsletter = $newsletterFactory->create();
+    $this->scheduledTask = $scheduledTaskFactory->create(Sending::TASK_TYPE, ScheduledTaskEntity::STATUS_SCHEDULED, $scheduledAt);
+    $this->sendingQueue = $sendingQueueFactory->create($this->scheduledTask, $this->newsletter);
+    $this->assertInstanceOf(SendingQueueEntity::class, $this->sendingQueue);
+  }
+
+  public function testToArrayReturnsExpectedResult() {
+    $expectedResult = [
+      'id' => $this->sendingQueue->getId(),
+      'type' => 'sending',
+      'status' => 'scheduled',
+      'priority' => 0,
+      'scheduled_at' => '2018-10-10 10:00:00',
+      'processed_at' => null,
+      'created_at' => !is_null($this->sendingQueue->getCreatedAt()) ? $this->sendingQueue->getCreatedAt()->format('Y-m-d H:i:s') : null,
+      'updated_at' => $this->sendingQueue->getUpdatedAt()->format('Y-m-d H:i:s'),
+      'deleted_at' => null,
+      'in_progress' => null,
+      'reschedule_count' => 0,
+      'meta' => null,
+      'task_id' => $this->scheduledTask->getId(),
+      'newsletter_id' => $this->newsletter->getId(),
+      'newsletter_rendered_body' => null,
+      'newsletter_rendered_subject' => null,
+      'count_total' => 0,
+      'count_processed' => 0,
+      'count_to_process' => 0,
+    ];
+
+    $this->assertSame($expectedResult, $this->sendingQueue->toArray());
+  }
+}