Replace \MailPoet\Tasks\Sending with Doctrine in SendingQueueTest

This commit also removes Sending::getSendingQueueEntity() as the last
calls to this method were removed when refactoring SendingQueueTest.

[MAILPOET-5682]

mailpoet/tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php

@@ -50,7 +50,6 @@ use MailPoet\Settings\TrackingConfig;
 use MailPoet\Subscribers\LinkTokens;
 use MailPoet\Subscribers\SubscribersRepository;
 use MailPoet\Subscription\SubscriptionUrlFactory;
-use MailPoet\Tasks\Sending as SendingTask;
 use MailPoet\Test\DataFactories\ScheduledTask as ScheduledTaskFactory;
 use MailPoet\Test\DataFactories\Segment as SegmentFactory;
 use MailPoet\Test\DataFactories\Subscriber as SubscriberFactory;
@@ -63,8 +62,8 @@ class SendingQueueTest extends \MailPoetTest {
   public $sendingQueueWorker;
   public $cronHelper;
   public $newsletterLink;
-  /* @var SendingTask */
-  public $queue;
+  /* @var SendingQueueEntity */
+  public $sendingQueue;
   public $newsletterSegment;
   public $newsletter;
   public $subscriberSegment;
@@ -104,10 +103,10 @@ class SendingQueueTest extends \MailPoetTest {
   private $scheduledTaskSubscribersRepository;
 
   /** @var ScheduledTaskEntity */
-  private $scheduledTaskEntity;
+  private $scheduledTask;
 
-  /** @var SendingQueueEntity */
-  private $sendingQueueEntity;
+  /** NewsletterEntity */
+  private $newsletterEntity;
 
   public function _before() {
     parent::_before();
@@ -117,6 +116,8 @@ class SendingQueueTest extends \MailPoetTest {
     $populator = $this->diContainer->get(Populator::class);
     $populator->up();
     $this->wp = $this->diContainer->get(WPFunctions::class);
+    $this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
+    $this->scheduledTaskSubscribersRepository = $this->diContainer->get(ScheduledTaskSubscribersRepository::class);
     $this->subscriber = $this->createSubscriber('john@doe.com', 'John', 'Doe');
     /** @var Segment $segment */
     $segment = Segment::create();
@@ -139,26 +140,27 @@ class SendingQueueTest extends \MailPoetTest {
     $this->newsletter->subject = Fixtures::get('newsletter_subject_template');
     $this->newsletter->body = Fixtures::get('newsletter_body_template');
     $this->newsletter->save();
+
+    $this->newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id);
+    $this->assertInstanceOf(NewsletterEntity::class, $this->newsletterEntity);
+
     /** @var NewsletterSegment $newsletterSegment */
     $newsletterSegment = NewsletterSegment::create();
     $this->newsletterSegment = $newsletterSegment;
     $this->newsletterSegment->newsletterId = $this->newsletter->id;
     $this->newsletterSegment->segmentId = (int)$this->segment->id;
     $this->newsletterSegment->save();
-    $this->queue = SendingTask::create();
-    $this->queue->newsletterId = $this->newsletter->id;
-    $this->queue->setSubscribers([$this->subscriber->getId()]);
-    $this->queue->countTotal = 1;
-    $this->queue->save();
 
-    $this->newslettersRepository = $this->diContainer->get(NewslettersRepository::class);
+    $this->sendingQueue = $this->createQueueWithTask($this->newsletterEntity);
+    $scheduledTask = $this->sendingQueue->getTask();
+    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
+    $this->scheduledTask = $scheduledTask;
+    $this->scheduledTaskSubscribersRepository->setSubscribers($this->scheduledTask, [$this->subscriber->getId()]);
 
-    $newsletterEntity = $this->newslettersRepository->findOneById($this->newsletter->id);
-    $this->assertInstanceOf(NewsletterEntity::class, $newsletterEntity);
-    $queue = $newsletterEntity->getLatestQueue();
+    $queue = $this->newsletterEntity->getLatestQueue();
     $this->assertInstanceOf(SendingQueueEntity::class, $queue);
     $this->newsletterLink = new NewsletterLinkEntity(
-      $newsletterEntity,
+      $this->newsletterEntity,
       $queue,
       '[link:subscription_instant_unsubscribe_url]',
       'abcde'
@@ -175,23 +177,13 @@ class SendingQueueTest extends \MailPoetTest {
     $this->segmentsRepository = $this->diContainer->get(SegmentsRepository::class);
     $this->tasksLinks = $this->diContainer->get(TasksLinks::class);
     $this->scheduledTasksRepository = $this->diContainer->get(ScheduledTasksRepository::class);
-    $this->scheduledTaskSubscribersRepository = $this->diContainer->get(ScheduledTaskSubscribersRepository::class);
     $this->subscribersRepository = $this->diContainer->get(SubscribersRepository::class);
     $this->sendingQueuesRepository = $this->diContainer->get(SendingQueuesRepository::class);
     $this->sendingQueueWorker = $this->getSendingQueueWorker();
-
-    $scheduledTaskEntity = $this->scheduledTasksRepository->findOneById($this->queue->taskId);
-    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTaskEntity);
-    $this->scheduledTaskEntity = $scheduledTaskEntity;
-
-    $sendingQueueEntity = $this->sendingQueuesRepository->findOneById($this->queue->id);
-    $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueueEntity);
-    $this->sendingQueueEntity = $sendingQueueEntity;
-    $this->entityManager->refresh($this->sendingQueueEntity);
   }
 
   private function getDirectUnsubscribeURL() {
-    return SubscriptionUrlFactory::getInstance()->getUnsubscribeUrl($this->subscriber, (int)$this->queue->id);
+    return SubscriptionUrlFactory::getInstance()->getUnsubscribeUrl($this->subscriber, (int)$this->sendingQueue->getId());
   }
 
   private function getTrackedUnsubscribeURL() {
@@ -200,7 +192,7 @@ class SendingQueueTest extends \MailPoetTest {
     $data = $links->createUrlDataObject(
       $this->subscriber->getId(),
       $linkTokens->getToken($this->subscriber),
-      $this->queue->id,
+      $this->sendingQueue->getId(),
       $this->newsletterLink->getHash(),
       false
     );
@@ -285,14 +277,14 @@ class SendingQueueTest extends \MailPoetTest {
       $this->entityManager
     );
     $sendingQueueWorker->sendNewsletters(
-      $this->scheduledTaskEntity,
+      $this->scheduledTask,
       $preparedSubscribers = [],
       $preparedNewsletters = [],
       $preparedSubscribers = [],
       $statistics[] = [
         'newsletter_id' => 1,
         'subscriber_id' => 1,
-        'queue_id' => $this->queue->id,
+        'queue_id' => $this->sendingQueue->getId(),
       ],
       microtime(true)
     );
@@ -302,10 +294,9 @@ class SendingQueueTest extends \MailPoetTest {
     // when sending is done and there are no more subscribers to process, continue
     // without enforcing execution limits. this allows the newsletter to be marked as sent
     // in the process() method and after that execution limits will be enforced
-    $queue = $this->queue;
-    $queue->status = SendingQueue::STATUS_COMPLETED;
-    $queue->save();
-    $this->entityManager->refresh($this->scheduledTaskEntity);
+    $this->scheduledTask->setStatus(SendingQueue::STATUS_COMPLETED);
+    $this->entityManager->persist($this->scheduledTask);
+    $this->entityManager->flush();
     $sendingQueueWorker = $this->make(
       $this->getSendingQueueWorker(),
       [
@@ -335,14 +326,14 @@ class SendingQueueTest extends \MailPoetTest {
       $this->entityManager
     );
     $sendingQueueWorker->sendNewsletters(
-      $this->scheduledTaskEntity,
+      $this->scheduledTask,
       $preparedSubscribers = [],
       $preparedNewsletters = [],
       $preparedSubscribers = [],
       $statistics[] = [
         'newsletter_id' => 1,
         'subscriber_id' => 1,
-        'queue_id' => $queue->id,
+        'queue_id' => $this->sendingQueue->getId(),
       ],
       microtime(true)
     );
@@ -381,7 +372,7 @@ class SendingQueueTest extends \MailPoetTest {
 
   public function testItDeletesQueueWhenNewsletterIsNotFound() {
     // queue exists
-    $queue = SendingQueue::findOne($this->queue->id);
+    $queue = SendingQueue::findOne($this->sendingQueue->getId());
     verify($queue)->notEquals(false);
 
     // delete newsletter
@@ -389,7 +380,7 @@ class SendingQueueTest extends \MailPoetTest {
 
     // queue no longer exists
     $this->sendingQueueWorker->process();
-    $queue = SendingQueue::findOne($this->queue->id);
+    $queue = SendingQueue::findOne($this->sendingQueue->getId());
     verify($queue)->false();
   }
 
@@ -470,7 +461,7 @@ class SendingQueueTest extends \MailPoetTest {
     verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT);
 
     // queue status is set to completed
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -490,7 +481,7 @@ class SendingQueueTest extends \MailPoetTest {
     // statistics entry should be created
     $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
       ->where('subscriber_id', $this->subscriber->getId())
-      ->where('queue_id', $this->queue->id)
+      ->where('queue_id', $this->sendingQueue->getId())
       ->findOne();
     verify($statistics)->notEquals(false);
   }
@@ -504,37 +495,20 @@ class SendingQueueTest extends \MailPoetTest {
     $subscriber1->setEmail('1@localhost.com');
     $subscribersRepository->persist($subscriber1);
 
-
     $subscriber2 = $this->createSubscriber('2@lcoalhost.com', 'first', 'last');
     $subscriber2->setStatus(SubscriberEntity::STATUS_SUBSCRIBED);
     $subscriber2->setSource('form');
     $subscriber2->setEmail('2@localhost.com');
     $subscribersRepository->persist($subscriber2);
 
-    $subscribersRepository->flush();
+    $sendingQueue = $this->createQueueWithTask($this->newsletterEntity);
 
-    $subscribers = [
-      $subscriber1,
-      $subscriber2,
-    ];
+    $sendingQueue->setNewsletterRenderedBody(['html' => '<p>Hello [subscriber:email]</p>', 'text' => 'Hello [subscriber:email]']);
+    $sendingQueue->setNewsletterRenderedSubject('News for [subscriber:email]');
+    $scheduledTask = $sendingQueue->getTask();
+    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
+    $this->scheduledTaskSubscribersRepository->setSubscribers($scheduledTask, [$subscriber1->getId(), $subscriber2->getId()]);
 
-    $subscriberIds = array_map(
-      function(SubscriberEntity $item): int {
-        return (int)$item->getId();
-      },
-      $subscribers
-    );
-
-    $queue = SendingTask::create();
-    $queue->newsletterRenderedBody = ['html' => '<p>Hello [subscriber:email]</p>', 'text' => 'Hello [subscriber:email]'];
-    $queue->newsletterRenderedSubject = 'News for [subscriber:email]';
-    $queue->setSubscribers($subscriberIds);
-    $queue->save();
-    $scheduledTaskEntity = $this->scheduledTasksRepository->findOneById($queue->taskId);
-    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTaskEntity);
-    $queueEntity = $scheduledTaskEntity->getSendingQueue();
-    $this->assertInstanceOf(SendingQueueEntity::class, $queueEntity);
-    $this->entityManager->refresh($queueEntity);
     $this->settings->set('tracking.level', TrackingConfig::LEVEL_BASIC);
 
     $newsletter = $this->newsletter;
@@ -548,11 +522,11 @@ class SendingQueueTest extends \MailPoetTest {
             return $subscriber->get('email');
           },
           'getProcessingMethod' => 'individual',
-          'send' => Expected::exactly(2, function($newsletter, $subscriberEmail, $extraParams) use ($subscribersRepository, $queue) {
+          'send' => Expected::exactly(2, function($newsletter, $subscriberEmail, $extraParams) use ($subscribersRepository, $sendingQueue) {
 
             $subscriber = $subscribersRepository->findOneBy(['email' => $subscriberEmail]);
             $subscriptionUrlFactory = SubscriptionUrlFactory::getInstance();
-            $unsubscribeUrl = $subscriptionUrlFactory->getUnsubscribeUrl($subscriber, (int)$queue->id);
+            $unsubscribeUrl = $subscriptionUrlFactory->getUnsubscribeUrl($subscriber, (int)$sendingQueue->getId());
             verify($newsletter['subject'])->equals('News for ' . $subscriberEmail);
             verify($newsletter['body']['html'])->equals('<p>Hello ' . $subscriberEmail . '</p>');
             verify($newsletter['body']['text'])->equals('Hello ' . $subscriberEmail);
@@ -572,7 +546,7 @@ class SendingQueueTest extends \MailPoetTest {
       Subscriber::findOne($subscriber2->getId()),
     ];
 
-    $sendingQueueWorker->processQueue($scheduledTaskEntity, $newsletter, $subscribersModels, $timer);
+    $sendingQueueWorker->processQueue($scheduledTask, $newsletter, $subscribersModels, $timer);
   }
 
   public function testItCanProcessSubscribersInBulk() {
@@ -604,7 +578,7 @@ class SendingQueueTest extends \MailPoetTest {
     verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT);
 
     // queue status is set to completed
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -624,7 +598,7 @@ class SendingQueueTest extends \MailPoetTest {
     // statistics entry should be created
     $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
       ->where('subscriber_id', $this->subscriber->getId())
-      ->where('queue_id', $this->queue->id)
+      ->where('queue_id', $this->sendingQueue->getId())
       ->findOne();
     verify($statistics)->notEquals(false);
   }
@@ -647,7 +621,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sendingQueueWorker->process();
 
     // queue status is set to completed
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -673,21 +647,20 @@ class SendingQueueTest extends \MailPoetTest {
     // statistics entry should be created
     $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
       ->where('subscriber_id', $this->subscriber->getId())
-      ->where('queue_id', $this->queue->id)
+      ->where('queue_id', $this->sendingQueue->getId())
       ->findOne();
     verify($statistics)->notEquals(false);
   }
 
   public function testItHandlesSendingErrorCorrectly() {
     $wrongSubscriber = $this->createSubscriber('doe@john.com>', 'Doe', 'John');
-    $queue = SendingTask::create();
-    $queue->newsletterId = $this->newsletter->id;
-    $queue->setSubscribers([
-      $this->subscriber->getId(),
-      $wrongSubscriber->getId(),
-    ]);
-    $queue->countTotal = 2;
-    $queue->save();
+
+    $sendingQueue = $this->createQueueWithTask($this->newsletterEntity);
+    $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
+    $scheduledTask = $sendingQueue->getTask();
+    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
+    $this->scheduledTaskSubscribersRepository->setSubscribers($scheduledTask, [$this->subscriber->getId(), $wrongSubscriber->getId()]);
+
     // Error that simulates sending error from the bridge
     $mailerError = new MailerError(
       MailerError::OPERATION_SEND,
@@ -723,17 +696,12 @@ class SendingQueueTest extends \MailPoetTest {
       $this->entityManager
     );
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($queue->id);
-    $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
-    $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
-    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
-
     $sendingQueueWorker->sendNewsletters(
       $scheduledTask,
       [$this->subscriber->getId(), $wrongSubscriber->getId()],
       [],
       [$this->subscriber->getEmail(), $wrongSubscriber->getEmail()],
-      ['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $queue->id],
+      ['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $sendingQueue->getId()],
       microtime(true)
     );
 
@@ -751,7 +719,7 @@ class SendingQueueTest extends \MailPoetTest {
       [$this->subscriber->getId()],
       [],
       [$this->subscriber->getEmail()],
-      ['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $queue->id],
+      ['newsletter_id' => 1, 'subscriber_id' => 1, 'queue_id' => $sendingQueue->getId()],
       microtime(true)
     );
 
@@ -766,11 +734,8 @@ class SendingQueueTest extends \MailPoetTest {
   }
 
   public function testItUpdatesUpdateTime() {
-    $originalUpdated = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->subHours(5)->toDateTimeString();
-
-    $this->queue->scheduled_at = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'));
-    $this->queue->updated_at = $originalUpdated;
-    $this->queue->save();
+    $originalUpdated = Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->subHours(5);
+    $this->setUpdatedAtForEntity($this->scheduledTask, $originalUpdated);
 
     $this->newsletter->type = NewsletterEntity::TYPE_WELCOME;
     $this->newsletterSegment->delete();
@@ -780,9 +745,7 @@ class SendingQueueTest extends \MailPoetTest {
     );
     $sendingQueueWorker->process();
 
-    $newScheduledTask = $this->scheduledTasksRepository->findOneById($this->queue->task_id);
-    $this->assertInstanceOf(ScheduledTaskEntity::class, $newScheduledTask);
-    verify($newScheduledTask->getUpdatedAt())->notEquals($originalUpdated);
+    verify($this->scheduledTask->getUpdatedAt())->notEquals($originalUpdated);
   }
 
   public function testItCanProcessWelcomeNewsletters() {
@@ -812,7 +775,7 @@ class SendingQueueTest extends \MailPoetTest {
     verify($updatedNewsletter->status)->equals(NewsletterEntity::STATUS_SENT);
 
     // queue status is set to completed
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -832,7 +795,7 @@ class SendingQueueTest extends \MailPoetTest {
     // statistics entry should be created
     $statistics = StatisticsNewsletters::where('newsletter_id', $this->newsletter->id)
       ->where('subscriber_id', $this->subscriber->getId())
-      ->where('queue_id', $this->queue->id)
+      ->where('queue_id', $this->sendingQueue->getId())
       ->findOne();
     verify($statistics)->notEquals(false);
   }
@@ -842,7 +805,6 @@ class SendingQueueTest extends \MailPoetTest {
     $this->subscriber->setStatus(SubscriberEntity::STATUS_UNSUBSCRIBED);
     $this->entityManager->flush();
     $this->newsletterSegment->delete();
-    $this->entityManager->refresh($this->sendingQueueEntity);
 
     $sendingQueueWorker = $this->getSendingQueueWorker(
       $this->construct(
@@ -856,7 +818,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sendingQueueWorker->process();
 
     // queue status is set to completed
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -875,11 +837,12 @@ class SendingQueueTest extends \MailPoetTest {
     $unsubscribedSubscriber = $subscriberFactory
       ->withStatus(SubscriberEntity::STATUS_UNSUBSCRIBED)
       ->create();
-    $this->queue->setSubscribers([
-      $this->subscriber->getId(), // subscriber that should be processed
-      $unsubscribedSubscriber->getId(), // subscriber that should be skipped
-    ]);
-    $this->entityManager->refresh($this->sendingQueueEntity);
+
+    $this->scheduledTaskSubscribersRepository->setSubscribers(
+      $this->scheduledTask,
+      [$this->subscriber->getId(), $unsubscribedSubscriber->getId()]
+    );
+
     $sendingQueueWorker = $this->getSendingQueueWorker(
       $this->construct(
         MailerTask::class,
@@ -894,7 +857,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sendingQueueWorker->process();
 
     // queue status is set to completed
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -909,15 +872,14 @@ class SendingQueueTest extends \MailPoetTest {
     verify($sendingQueue->getCountToProcess())->equals(0);
   }
 
-  public function testItRemovesNonexistentSubscribersFromProcessingList() {
-    $queue = $this->queue;
-    $queue->setSubscribers([
-      $this->subscriber->getId(),
-      1234564545,
-    ]);
-    $queue->countTotal = 2;
-    $queue->save();
-    $this->entityManager->refresh($this->sendingQueueEntity);
+  public function testItRemovesSubscribersFromProcessingListWhenNewsletterHasSegmentAndSubscriberIsNotPartOfIt() {
+    $subscriberNotPartOfNewsletterSegment = $this->createSubscriber('subscriber1@mailpoet.com', 'Subscriber', 'One');
+
+    $this->scheduledTaskSubscribersRepository->setSubscribers(
+      $this->scheduledTask,
+      [$this->subscriber->getId(), $subscriberNotPartOfNewsletterSegment->getId()]
+    );
+
     $sendingQueueWorker = $this->sendingQueueWorker;
     $sendingQueueWorker->mailerTask = $this->construct(
       MailerTask::class,
@@ -930,20 +892,14 @@ class SendingQueueTest extends \MailPoetTest {
     );
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($queue->id);
-    $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
-    $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
-    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
-    $this->sendingQueuesRepository->refresh($sendingQueue);
-    $this->scheduledTasksRepository->refresh($scheduledTask);
     // queue subscriber processed/to process count is updated
-    verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED))
+    verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED))
       ->equals([]);
-    verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED))
+    verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED))
       ->equals([$this->subscriber]);
-    verify($sendingQueue->getCountTotal())->equals(1);
-    verify($sendingQueue->getCountProcessed())->equals(1);
-    verify($sendingQueue->getCountToProcess())->equals(0);
+    verify($this->sendingQueue->getCountTotal())->equals(1);
+    verify($this->sendingQueue->getCountProcessed())->equals(1);
+    verify($this->sendingQueue->getCountToProcess())->equals(0);
 
     // statistics entry should be created only for 1 subscriber
     $statistics = StatisticsNewsletters::findMany();
@@ -951,16 +907,17 @@ class SendingQueueTest extends \MailPoetTest {
   }
 
   public function testItDoesNotCallMailerWithEmptyBatch() {
-    $queue = $this->queue;
     $subscribers = [];
     while (count($subscribers) < 2 * SendingThrottlingHandler::BATCH_SIZE) {
       $subscribers[] = 1234564545 + count($subscribers);
     }
     $subscribers[] = $this->subscriber->getId();
-    $queue->setSubscribers($subscribers);
-    $queue->countTotal = count($subscribers);
-    $queue->save();
-    $this->entityManager->refresh($this->sendingQueueEntity);
+
+    $this->scheduledTaskSubscribersRepository->setSubscribers($this->scheduledTask, $subscribers);
+    $this->sendingQueue->setCountTotal(count($subscribers));
+    $this->entityManager->persist($this->sendingQueue);
+    $this->entityManager->flush();
+
     $sendingQueueWorker = $this->sendingQueueWorker;
     $sendingQueueWorker->mailerTask = $this->construct(
       MailerTask::class,
@@ -973,7 +930,7 @@ class SendingQueueTest extends \MailPoetTest {
     );
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
     $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
@@ -990,14 +947,11 @@ class SendingQueueTest extends \MailPoetTest {
   }
 
   public function testItUpdatesQueueSubscriberCountWhenNoneOfSubscribersExist() {
-    $queue = $this->queue;
-    $queue->setSubscribers([
-      123,
-      456,
-    ]);
-    $queue->countTotal = 2;
-    $queue->save();
-    $this->entityManager->refresh($this->sendingQueueEntity);
+    $this->scheduledTaskSubscribersRepository->setSubscribers($this->scheduledTask, [123, 456,]);
+    $this->sendingQueue->setCountTotal(2);
+    $this->entityManager->persist($this->sendingQueue);
+    $this->entityManager->flush();
+
     $sendingQueueWorker = $this->sendingQueueWorker;
     $sendingQueueWorker->mailerTask = $this->construct(
       MailerTask::class,
@@ -1006,20 +960,14 @@ class SendingQueueTest extends \MailPoetTest {
     );
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
-    $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
-    $scheduledTask = $this->scheduledTasksRepository->findOneBySendingQueue($sendingQueue);
-    $this->assertInstanceOf(ScheduledTaskEntity::class, $scheduledTask);
-    $this->sendingQueuesRepository->refresh($sendingQueue);
-    $this->scheduledTasksRepository->refresh($scheduledTask);
     // queue subscriber processed/to process count is updated
-    verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED))
+    verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_UNPROCESSED))
       ->equals([]);
-    verify($scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED))
+    verify($this->scheduledTask->getSubscribersByProcessed(ScheduledTaskSubscriberEntity::STATUS_PROCESSED))
       ->equals([]);
-    verify($sendingQueue->getCountTotal())->equals(0);
-    verify($sendingQueue->getCountProcessed())->equals(0);
-    verify($sendingQueue->getCountToProcess())->equals(0);
+    verify($this->sendingQueue->getCountTotal())->equals(0);
+    verify($this->sendingQueue->getCountProcessed())->equals(0);
+    verify($this->sendingQueue->getCountToProcess())->equals(0);
   }
 
   public function testItDoesNotSendToTrashedSubscribers() {
@@ -1034,10 +982,9 @@ class SendingQueueTest extends \MailPoetTest {
     $subscriber = $this->subscriber;
     $subscriber->setDeletedAt(Carbon::now());
     $this->entityManager->flush();
-    $this->entityManager->refresh($this->sendingQueueEntity);
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $this->sendingQueuesRepository->refresh($sendingQueue);
     verify($sendingQueue->getCountTotal())->equals(0);
@@ -1061,10 +1008,9 @@ class SendingQueueTest extends \MailPoetTest {
     $subscriber = $this->subscriber;
     $subscriber->setStatus($subscriberStatus);
     $this->entityManager->flush();
-    $this->entityManager->refresh($this->sendingQueueEntity);
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $this->sendingQueuesRepository->refresh($sendingQueue);
     verify($sendingQueue->getCountTotal())->equals($expectSending ? 1 : 0);
@@ -1095,10 +1041,9 @@ class SendingQueueTest extends \MailPoetTest {
     $subscriber = $this->subscriber;
     $subscriber->setStatus(SubscriberEntity::STATUS_UNSUBSCRIBED);
     $this->entityManager->flush();
-    $this->entityManager->refresh($this->sendingQueueEntity);
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $this->sendingQueuesRepository->refresh($sendingQueue);
     verify($sendingQueue->getCountTotal())->equals(0);
@@ -1116,10 +1061,9 @@ class SendingQueueTest extends \MailPoetTest {
     $subscriberSegment = $this->subscriberSegment;
     $subscriberSegment->status = SubscriberEntity::STATUS_UNSUBSCRIBED;
     $subscriberSegment->save();
-    $this->entityManager->refresh($this->sendingQueueEntity);
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $this->sendingQueuesRepository->refresh($sendingQueue);
     verify($sendingQueue->getCountTotal())->equals(0);
@@ -1137,10 +1081,9 @@ class SendingQueueTest extends \MailPoetTest {
     $subscriber = $this->subscriber;
     $subscriber->setStatus(SubscriberEntity::STATUS_INACTIVE);
     $this->entityManager->flush();
-    $this->entityManager->refresh($this->sendingQueueEntity);
     $sendingQueueWorker->process();
 
-    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->queue->id);
+    $sendingQueue = $this->sendingQueuesRepository->findOneById($this->sendingQueue->getId());
     $this->assertInstanceOf(SendingQueueEntity::class, $sendingQueue);
     $this->sendingQueuesRepository->refresh($sendingQueue);
     verify($sendingQueue->getCountTotal())->equals(0);
@@ -1180,7 +1123,7 @@ class SendingQueueTest extends \MailPoetTest {
     );
     try {
       $sendingQueueWorker->sendNewsletters(
-        $this->scheduledTaskEntity,
+        $this->scheduledTask,
         $preparedSubscribers = [],
         $preparedNewsletters = [],
         $preparedSubscribers = [],
@@ -1196,7 +1139,7 @@ class SendingQueueTest extends \MailPoetTest {
     verify($mailerLog['error'])->equals(
       [
         'operation' => 'processed_list_update',
-        'error_message' => "QUEUE-{$this->sendingQueueEntity->getId()}-PROCESSED-LIST-UPDATE",
+        'error_message' => "QUEUE-{$this->sendingQueue->getId()}-PROCESSED-LIST-UPDATE",
       ]
     );
   }
@@ -1325,7 +1268,7 @@ class SendingQueueTest extends \MailPoetTest {
       )
     );
     $sendingQueueWorker->process();
-    $meta = $this->queue->getSendingQueueEntity()->getMeta();
+    $meta = $this->sendingQueue->getMeta();
     verify(isset($meta['campaignId']))->true();
     $campaignId = $meta['campaignId'];
     verify(strlen($campaignId))->equals(16);
@@ -1349,7 +1292,7 @@ class SendingQueueTest extends \MailPoetTest {
       )
     );
     $sendingQueueWorker->process();
-    $meta = $this->queue->getSendingQueueEntity()->getMeta();
+    $meta = $this->sendingQueue->getMeta();
     verify(isset($meta['campaignId']))->true();
     $campaignId = $meta['campaignId'];
     verify($mailerTaskExtraParams['meta']['campaign_id'])->equals($campaignId);
@@ -1363,9 +1306,10 @@ class SendingQueueTest extends \MailPoetTest {
     $segment2->subscriberId = (int)$secondSubscriber->getId();
     $segment2->segmentId = (int)$this->segment->id;
     $segment2->save();
-    $this->queue->setSubscribers([$this->subscriber->getId(), $secondSubscriber->getId()]);
-    $this->queue->countTotal = 2;
-    $this->queue->save();
+    $this->scheduledTaskSubscribersRepository->setSubscribers(
+      $this->scheduledTask,
+      [$this->subscriber->getId(), $secondSubscriber->getId()]
+    );
     $sendingQueueWorker = $this->getSendingQueueWorker(
       $this->construct(
         MailerTask::class,
@@ -1382,7 +1326,7 @@ class SendingQueueTest extends \MailPoetTest {
       )
     );
     $sendingQueueWorker->process();
-    $meta = $this->queue->getSendingQueueEntity()->getMeta();
+    $meta = $this->sendingQueue->getMeta();
     verify(isset($meta['campaignId']))->true();
     $campaignId = $meta['campaignId'];
     verify(count($mailerTaskCampaignIds))->equals(2);