Remove phpstan errors from integration Cron tests

[MAILPOET-3235]

tests/integration/Cron/CronWorkerRunnerTest.php

@@ -44,7 +44,9 @@ class CronWorkerRunnerTest extends \MailPoetTest {
     $task = $this->createScheduledTask();
     $result = $this->cronWorkerRunner->run($worker);
     expect($result)->true();
-    expect(ScheduledTask::findOne($task->id)->status)->null();
+    $scheduledTask = ScheduledTask::findOne($task->id);
+    assert($scheduledTask instanceof ScheduledTask);
+    expect($scheduledTask->status)->null();
   }
 
   public function testItProcessesTask() {
@@ -56,7 +58,9 @@ class CronWorkerRunnerTest extends \MailPoetTest {
     $task = $this->createRunningTask();
     $result = $this->cronWorkerRunner->run($worker);
     expect($result)->true();
-    expect(ScheduledTask::findOne($task->id)->status)->same(ScheduledTask::STATUS_COMPLETED);
+    $scheduledTask = ScheduledTask::findOne($task->id);
+    assert($scheduledTask instanceof ScheduledTask);
+    expect($scheduledTask->status)->same(ScheduledTask::STATUS_COMPLETED);
   }
 
   public function testItFailsToProcessWithoutTasks() {
@@ -94,7 +98,9 @@ class CronWorkerRunnerTest extends \MailPoetTest {
 
     $result = $this->cronWorkerRunner->run($worker);
     expect($result)->false();
-    expect(ScheduledTask::findOne()->scheduledAt)->same($inOneWeek->format('Y-m-d H:i:s'));
+    $scheduledTask = ScheduledTask::findOne();
+    assert($scheduledTask instanceof ScheduledTask);
+    expect($scheduledTask->scheduledAt)->same($inOneWeek->format('Y-m-d H:i:s'));
   }
 
   public function testItWillRescheduleTaskIfItIsRunningForTooLong() {
@@ -105,6 +111,7 @@ class CronWorkerRunnerTest extends \MailPoetTest {
 
     $task = $this->createRunningTask();
     $task = ScheduledTask::findOne($task->id); // make sure `updated_at` is set by the DB
+    assert($task instanceof ScheduledTask);
 
     $result = $this->cronWorkerRunner->run($worker);
     expect($result)->true();
@@ -118,6 +125,7 @@ class CronWorkerRunnerTest extends \MailPoetTest {
     expect($result)->true();
 
     $task = ScheduledTask::findOne($task->id);
+    assert($task instanceof ScheduledTask);
     expect($task->scheduledAt)->greaterThan($scheduledAt);
     expect($task->status)->same(ScheduledTask::STATUS_SCHEDULED);
     expect($task->inProgress)->isEmpty();
@@ -138,6 +146,7 @@ class CronWorkerRunnerTest extends \MailPoetTest {
     } catch (\Exception $e) {
       expect($e->getMessage())->equals('test error');
       $task = ScheduledTask::findOne($task->id);
+      assert($task instanceof ScheduledTask);
       expect($task->scheduledAt)->greaterThan($scheduledAt);
       expect($task->status)->same(ScheduledTask::STATUS_SCHEDULED);
       expect($task->rescheduleCount)->equals(1);
@@ -160,6 +169,7 @@ class CronWorkerRunnerTest extends \MailPoetTest {
     } catch (\Exception $e) {
       expect($e->getCode())->same(CronHelper::DAEMON_EXECUTION_LIMIT_REACHED);
       $task = ScheduledTask::findOne($task->id);
+      assert($task instanceof ScheduledTask);
       expect($scheduledAt)->equals($task->scheduledAt);
       expect($task->status)->null();
       expect($task->rescheduleCount)->equals(0);

tests/integration/Cron/Workers/InactiveSubscribersTest.php

@@ -41,6 +41,7 @@ class InactiveSubscribersTest extends \MailPoetTest {
       ->where('status', ScheduledTask::STATUS_SCHEDULED)
       ->findOne();
 
+    assert($task instanceof ScheduledTask);
     expect($task)->isInstanceOf(ScheduledTask::class);
     expect($task->scheduledAt)->greaterThan(new Carbon());
   }
@@ -73,6 +74,7 @@ class InactiveSubscribersTest extends \MailPoetTest {
       ->where('status', ScheduledTask::STATUS_SCHEDULED)
       ->findOne();
 
+    assert($task instanceof ScheduledTask);
     expect($task)->isInstanceOf(ScheduledTask::class);
     expect($task->scheduledAt)->greaterThan(new Carbon());
   }

tests/integration/Cron/Workers/SchedulerTest.php

@@ -24,6 +24,7 @@ use MailPoet\Tasks\Sending as SendingTask;
 use MailPoet\WP\Functions as WPFunctions;
 use MailPoetVendor\Carbon\Carbon;
 use MailPoetVendor\Idiorm\ORM;
+use WP_User;
 
 class SchedulerTest extends \MailPoetTest {
   public $cronHelper;
@@ -87,6 +88,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, 'immediately');
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -98,11 +100,13 @@ class SchedulerTest extends \MailPoetTest {
 
   public function testItCanRescheduleQueueDeliveryTime() {
     $newsletter = $this->_createNewsletter();
+    assert($newsletter instanceof Newsletter);
     $newsletterOptionField =
       $this->_createNewsletterOptionField('intervalType', Newsletter::TYPE_WELCOME);
     $newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, 'daily');
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -112,6 +116,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletterOption->value = 'daily';
     $newsletterOption->save();
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     expect($queue->scheduledAt)->null();
     $newsletter->schedule = '0 5 * * *'; // set it to daily at 5
     $scheduler->deleteQueueOrUpdateNextRunDate($queue, $newsletter);
@@ -135,6 +140,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -158,6 +164,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -180,6 +187,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -201,6 +209,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -309,6 +318,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletterOption = $this->_createNewsletterOption($newsletterOptionField->id, $newsletter->id, $segment->id);
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -340,6 +350,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -371,6 +382,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -394,6 +406,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
 
@@ -416,6 +429,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $queue = $this->_createQueue($newsletter->id);
     $scheduler = new Scheduler($this->subscribersFinder, $this->loggerFactory, $this->cronHelper);
 
@@ -431,6 +445,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($updatedQueue->status)->null();
     // set newsletter's status to sending
     $updatedNewsletter = Newsletter::findOne($newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENDING);
   }
 
@@ -479,6 +494,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
+    assert($newsletter instanceof Newsletter);
     $scheduler = new Scheduler($this->subscribersFinder, $this->loggerFactory, $this->cronHelper);
 
     // return true
@@ -486,6 +502,7 @@ class SchedulerTest extends \MailPoetTest {
     // create notification history
     $notificationHistory = Newsletter::where('parent_id', $newsletter->id)
       ->findOne();
+    assert($notificationHistory instanceof Newsletter);
     expect($notificationHistory)->notEmpty();
     // update queue with a list of subscribers to process and change newsletter id
     // to that of the notification history
@@ -498,6 +515,7 @@ class SchedulerTest extends \MailPoetTest {
     // set notification history's status to sending
     $updatedNotificationHistory = Newsletter::where('parent_id', $newsletter->id)
       ->findOne();
+    assert($updatedNotificationHistory instanceof Newsletter);
     expect($updatedNotificationHistory->status)->equals(Newsletter::STATUS_SENDING);
   }
 
@@ -618,6 +636,7 @@ class SchedulerTest extends \MailPoetTest {
 
     $scheduler->processScheduledStandardNewsletter($newsletter, $queue);
     $refetchedTask = ScheduledTask::where('id', $task->id)->findOne();
+    assert($refetchedTask instanceof ScheduledTask);
     expect($refetchedTask->scheduledAt)->lessThan(Carbon::createFromTimestamp(WPFunctions::get()->currentTime('timestamp'))->addHours(1));
   }
 
@@ -724,6 +743,7 @@ class SchedulerTest extends \MailPoetTest {
     $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->loggerFactory, $this->cronHelper);
     $scheduler->process();
     $newQueue = ScheduledTask::findOne($queue->taskId);
+    assert($newQueue instanceof ScheduledTask);
     expect($newQueue->updatedAt)->notEquals($originalUpdated);
   }
 
@@ -817,6 +837,7 @@ class SchedulerTest extends \MailPoetTest {
       );
     }
     $user = get_user_by('login', $username);
+    assert($user instanceof WP_User);
     wp_update_user(
       [
         'ID' => $user->ID,

tests/integration/Cron/Workers/SendingQueue/MigrationTest.php

@@ -82,7 +82,9 @@ class MigrationTest extends \MailPoetTest {
     SendingQueue::deleteMany();
     $task = $this->createScheduledTask();
     $this->worker->prepareTaskStrategy($task, microtime(true));
-    expect(ScheduledTask::findOne($task->id)->status)->equals(ScheduledTask::STATUS_COMPLETED);
+    $task = ScheduledTask::findOne($task->id);
+    assert($task instanceof ScheduledTask);
+    expect($task->status)->equals(ScheduledTask::STATUS_COMPLETED);
   }
 
   public function testItMigratesSendingQueuesAndSubscribers() {
@@ -98,7 +100,9 @@ class MigrationTest extends \MailPoetTest {
     expect(ScheduledTaskSubscriber::whereGt('task_id', 0)->count())->equals(4); // 2 for running, 2 for paused
 
     $queue = SendingQueue::findOne($this->queueRunning->id);
+    assert($queue instanceof SendingQueue);
     $task = ScheduledTask::findOne($queue->taskId);
+    assert($task instanceof ScheduledTask);
     expect($task->type)->equals(SendingTask::TASK_TYPE);
 
     $migratedSubscribers = ScheduledTaskSubscriber::where('task_id', $queue->taskId)

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

@@ -397,6 +397,7 @@ class SendingQueueTest extends \MailPoetTest {
 
     // newsletter status is set to sent
     $updatedNewsletter = Newsletter::findOne($this->newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
 
     // queue status is set to completed
@@ -450,6 +451,7 @@ class SendingQueueTest extends \MailPoetTest {
 
     // newsletter status is set to sent
     $updatedNewsletter = Newsletter::findOne($this->newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
 
     // queue status is set to completed
@@ -506,6 +508,7 @@ class SendingQueueTest extends \MailPoetTest {
 
     // newsletter status is set to sent and sent_at date is populated
     $updatedNewsletter = Newsletter::findOne($this->newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
     expect($updatedNewsletter->sentAt)->equals($updatedQueue->processedAt);
 
@@ -548,6 +551,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sendingQueueWorker->process();
 
     $newQueue = ScheduledTask::findOne($this->queue->task_id);
+    assert($newQueue instanceof ScheduledTask);
     expect($newQueue->updatedAt)->notEquals($originalUpdated);
   }
 
@@ -579,6 +583,7 @@ class SendingQueueTest extends \MailPoetTest {
 
     // newsletter status is set to sent
     $updatedNewsletter = Newsletter::findOne($this->newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
 
     // queue status is set to completed
@@ -859,6 +864,7 @@ class SendingQueueTest extends \MailPoetTest {
 
     // newsletter is sent and hash remains intact
     $updatedNewsletter = Newsletter::findOne($this->newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
     expect($updatedNewsletter->hash)->equals($this->newsletter->hash);
   }

tests/integration/Cron/Workers/SendingQueue/Tasks/LinksTest.php

@@ -20,6 +20,7 @@ class LinksTest extends \MailPoetTest {
     $result = Links::saveLinks($links, $newsletter, $queue);
     $newsletterLink = NewsletterLink::where('hash', $links[0]['hash'])
       ->findOne();
+    assert($newsletterLink instanceof NewsletterLink);
     expect($newsletterLink->newsletterId)->equals($newsletter->id);
     expect($newsletterLink->queueId)->equals($queue->id);
     expect($newsletterLink->url)->equals($links[0]['link']);
@@ -52,6 +53,7 @@ class LinksTest extends \MailPoetTest {
     $result = Links::process($renderedNewsletter, $newsletter, $queue);
     $newsletterLink = NewsletterLink::where('newsletter_id', $newsletter->id)
       ->findOne();
+    assert($newsletterLink instanceof NewsletterLink);
     expect($result['html'])->stringContainsString($newsletterLink->hash);
   }
 

tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php

@@ -158,7 +158,8 @@ class NewsletterTest extends \MailPoetTest {
     $newsletterTask->trackingEnabled = true;
     $newsletterTask->preProcessNewsletter($this->newsletter, $this->queue);
     $link = NewsletterLink::where('newsletter_id', $this->newsletter->id)
-      ->findOne();
+    ->findOne();
+    assert($link instanceof NewsletterLink);
     /** @var SendingQueue $updatedQueue */
     $updatedQueue = SendingQueue::findOne($this->queue->id);
     $updatedQueue = SendingTask::createFromQueue($updatedQueue);
@@ -226,6 +227,7 @@ class NewsletterTest extends \MailPoetTest {
     $result = $newsletterTask->preProcessNewsletter($this->newsletter, $this->queue);
     $newsletterPost = NewsletterPost::where('newsletter_id', $this->newsletter->id)
       ->findOne();
+    assert($newsletterPost instanceof NewsletterPost);
     expect($result)->notEquals(false);
     expect($newsletterPost->postId)->equals('10');
   }
@@ -241,6 +243,7 @@ class NewsletterTest extends \MailPoetTest {
     $newsletter->save();
     $this->newsletterTask->markNewsletterAsSent($newsletter, $queue);
     $updatedNewsletter = Newsletter::findOne($newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
     expect($updatedNewsletter->sentAt)->equals($queue->processedAt);
 
@@ -250,6 +253,7 @@ class NewsletterTest extends \MailPoetTest {
     $newsletter->save();
     $this->newsletterTask->markNewsletterAsSent($newsletter, $queue);
     $updatedNewsletter = Newsletter::findOne($newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->equals(Newsletter::STATUS_SENT);
     expect($updatedNewsletter->sentAt)->equals($queue->processedAt);
 
@@ -259,6 +263,7 @@ class NewsletterTest extends \MailPoetTest {
     $newsletter->save();
     $this->newsletterTask->markNewsletterAsSent($newsletter, $queue);
     $updatedNewsletter = Newsletter::findOne($newsletter->id);
+    assert($updatedNewsletter instanceof Newsletter);
     expect($updatedNewsletter->status)->notEquals(Newsletter::STATUS_SENT);
   }
 
@@ -401,6 +406,7 @@ class NewsletterTest extends \MailPoetTest {
     $queueMock->taskId = $queue->taskId;
 
     $sendingQueue = ORM::forTable(SendingQueue::$_table)->findOne($queue->id);
+    assert($sendingQueue instanceof ORM);
     $sendingQueue->set('newsletter_rendered_body', 'a:2:{s:4:"html"');
     $sendingQueue->save();
     try {
@@ -433,6 +439,7 @@ class NewsletterTest extends \MailPoetTest {
 
     // properly serialized object
     $sendingQueue = ORM::forTable(SendingQueue::$_table)->findOne($queue->id);
+    assert($sendingQueue instanceof ORM);
     $sendingQueue->set('newsletter_rendered_body', 'a:2:{s:4:"html";s:4:"test";s:4:"text";s:4:"test";}');
     $sendingQueue->save();
 

tests/integration/Cron/Workers/SendingQueue/Tasks/PostsTest.php

@@ -41,6 +41,7 @@ class PostsTest extends \MailPoetTest {
     expect($this->postsTask->extractAndSave($renderedNewsletter, $newsletter))->equals(true);
     $newsletterPost = NewsletterPost::where('newsletter_id', $newsletter->parentId)
       ->findOne();
+    assert($newsletterPost instanceof NewsletterPost);
     expect($newsletterPost->postId)->equals($postId);
   }
 

tests/integration/Cron/Workers/SendingQueue/Tasks/ShortcodesTest.php

@@ -7,6 +7,7 @@ use MailPoet\Models\Newsletter;
 use MailPoet\Models\SendingQueue;
 use MailPoet\Models\Subscriber;
 use MailPoetVendor\Idiorm\ORM;
+use WP_Post;
 
 class ShortcodesTest extends \MailPoetTest {
   public $wPPost;
@@ -42,6 +43,7 @@ class ShortcodesTest extends \MailPoetTest {
 
   public function testItCanReplaceShortcodesInOneStringUsingContentsFromAnother() {
     $wpPost = get_post($this->wPPost);
+    assert($wpPost instanceof WP_Post);
     $content = 'Subject line with one shortcode: [newsletter:post_title]';
     $contentSource = '<a data-post-id="' . $this->wPPost . '" href="#">latest post</a>';
 

tests/integration/Cron/Workers/UnsubscribeTokensTest.php

@@ -60,6 +60,8 @@ class UnsubscribeTokensTest extends \MailPoetTest {
     $worker->processTaskStrategy(ScheduledTask::createOrUpdate(), microtime(true));
     $this->newsletterWithToken = Newsletter::findOne($this->newsletterWithToken->id);
     $this->newsletterWithoutToken = Newsletter::findOne($this->newsletterWithoutToken->id);
+    assert($this->newsletterWithToken instanceof Newsletter);
+    assert($this->newsletterWithoutToken instanceof Newsletter);
     expect($this->newsletterWithToken->unsubscribeToken)->equals('aaabbbcccdddeee');
     expect(strlen($this->newsletterWithoutToken->unsubscribeToken))->equals(15);
   }

tests/integration/Cron/Workers/WooCommerceOrdersTest.php

@@ -64,24 +64,28 @@ class WooCommerceOrdersTest extends \MailPoetTest {
     expect($this->worker->checkProcessingRequirements())->true();
     $this->cronWorkerRunner->run($this->worker);
     $task = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findOne();
+    assert($task instanceof ScheduledTask);
     expect($task->status)->equals(ScheduledTask::STATUS_SCHEDULED);
 
     // 2. prepare
     expect($this->worker->checkProcessingRequirements())->true();
     $this->cronWorkerRunner->run($this->worker);
     $task = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findOne();
+    assert($task instanceof ScheduledTask);
     expect($task->status)->null(); // null means 'running'
 
     // 3. run
     expect($this->worker->checkProcessingRequirements())->true();
     $this->cronWorkerRunner->run($this->worker);
     $task = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findOne();
+    assert($task instanceof ScheduledTask);
     expect($task->status)->equals(ScheduledTask::STATUS_COMPLETED);
 
     // 4. complete (do not schedule again)
     expect($this->worker->checkProcessingRequirements())->false();
     $this->cronWorkerRunner->run($this->worker);
     $task = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findOne();
+    assert($task instanceof ScheduledTask);
     expect($task->status)->equals(ScheduledTask::STATUS_COMPLETED);
 
     $tasks = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findMany();
@@ -116,11 +120,13 @@ class WooCommerceOrdersTest extends \MailPoetTest {
     $this->cronWorkerRunner->run($this->worker); // run for 1, 2, 3
 
     $task = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findOne();
+    assert($task instanceof ScheduledTask);
     expect($task->getMeta())->equals(['last_processed_id' => 3]);
 
     $this->cronWorkerRunner->run($this->worker); // run for 4, 5
 
     $task = ScheduledTask::where('type', WooCommercePastOrders::TASK_TYPE)->findOne();
+    assert($task instanceof ScheduledTask);
     expect($task->getMeta())->equals(['last_processed_id' => 5]);
 
     $this->cronWorkerRunner->run($this->worker); // complete