diff --git a/mailpoet/tests/integration/API/APITest.php b/mailpoet/tests/integration/API/APITest.php
index e55bca5b44..768af8fab7 100644
--- a/mailpoet/tests/integration/API/APITest.php
+++ b/mailpoet/tests/integration/API/APITest.php
@@ -6,7 +6,7 @@ use MailPoet\API\API;
 
 class APITest extends \MailPoetTest {
   public function testItCallsMPAPI() {
-    expect(API::MP('v1'))->isInstanceOf('MailPoet\API\MP\v1\API');
+    verify(API::MP('v1'))->instanceOf('MailPoet\API\MP\v1\API');
   }
 
   public function testItThrowsErrorWhenWrongMPAPIVersionIsCalled() {
diff --git a/mailpoet/tests/integration/API/JSON/v1/DynamicSegmentsTest.php b/mailpoet/tests/integration/API/JSON/v1/DynamicSegmentsTest.php
index 0746b49f3b..6c925ec529 100644
--- a/mailpoet/tests/integration/API/JSON/v1/DynamicSegmentsTest.php
+++ b/mailpoet/tests/integration/API/JSON/v1/DynamicSegmentsTest.php
@@ -28,14 +28,14 @@ class DynamicSegmentsTest extends \MailPoetTest {
   public function testGetReturnsResponse() {
     $segment = $this->createDynamicSegmentEntity('s1', '');
     $response = $this->endpoint->get(['id' => $segment->getId()]);
-    expect($response)->isInstanceOf('\MailPoet\API\JSON\SuccessResponse');
+    verify($response)->instanceOf('\MailPoet\API\JSON\SuccessResponse');
     verify($response->status)->equals(self::SUCCESS_RESPONSE_CODE);
     verify($response->data['id'])->equals($segment->getId());
   }
 
   public function testGetReturnsError() {
     $response = $this->endpoint->get(['id' => 5]);
-    expect($response)->isInstanceOf('\MailPoet\API\JSON\ErrorResponse');
+    verify($response)->instanceOf('\MailPoet\API\JSON\ErrorResponse');
     verify($response->status)->equals(self::SEGMENT_NOT_FOUND_RESPONSE_CODE);
   }
 
@@ -49,7 +49,7 @@ class DynamicSegmentsTest extends \MailPoetTest {
         'action' => UserRole::TYPE,
       ]],
     ]);
-    expect($response)->isInstanceOf('\MailPoet\API\JSON\SuccessResponse');
+    verify($response)->instanceOf('\MailPoet\API\JSON\SuccessResponse');
     verify($response->status)->equals(self::SUCCESS_RESPONSE_CODE);
     verify($response->data['name'])->equals('Test dynamic');
   }
@@ -58,7 +58,7 @@ class DynamicSegmentsTest extends \MailPoetTest {
     $response = $this->endpoint->save([
       'name' => 'Test dynamic',
     ]);
-    expect($response)->isInstanceOf('\MailPoet\API\JSON\ErrorResponse');
+    verify($response)->instanceOf('\MailPoet\API\JSON\ErrorResponse');
     verify($response->status)->equals(self::INVALID_DATA_RESPONSE_CODE);
     verify($response->errors[0]['message'])->equals('Please add at least one condition for filtering.');
   }
@@ -74,7 +74,7 @@ class DynamicSegmentsTest extends \MailPoetTest {
     ];
     $this->endpoint->save($data);
     $response = $this->endpoint->save($data);
-    expect($response)->isInstanceOf('\MailPoet\API\JSON\ErrorResponse');
+    verify($response)->instanceOf('\MailPoet\API\JSON\ErrorResponse');
     verify($response->status)->equals(self::INVALID_DATA_RESPONSE_CODE);
     verify($response->errors[0]['message'])->equals('Another record already exists. Please specify a different "name".');
   }
@@ -89,7 +89,7 @@ class DynamicSegmentsTest extends \MailPoetTest {
     ];
     $this->endpoint->save($data);
     $response = $this->endpoint->save($data);
-    expect($response)->isInstanceOf('\MailPoet\API\JSON\ErrorResponse');
+    verify($response)->instanceOf('\MailPoet\API\JSON\ErrorResponse');
     verify($response->status)->equals(self::INVALID_DATA_RESPONSE_CODE);
     verify($response->errors[0]['message'])->equals('Please specify a name.');
   }
diff --git a/mailpoet/tests/integration/API/JSON/v1/SettingsTest.php b/mailpoet/tests/integration/API/JSON/v1/SettingsTest.php
index cd31d5c812..8e309bec20 100644
--- a/mailpoet/tests/integration/API/JSON/v1/SettingsTest.php
+++ b/mailpoet/tests/integration/API/JSON/v1/SettingsTest.php
@@ -301,16 +301,16 @@ class SettingsTest extends \MailPoetTest {
   public function testItCanDeleteSetting() {
     $this->settings->set('setting_to_be_deleted', true);
     $response = $this->endpoint->delete('setting_to_be_deleted');
-    expect($response)->isInstanceOf(SuccessResponse::class);
+    verify($response)->instanceOf(SuccessResponse::class);
     verify($this->settings->get('setting_to_be_deleted'))->null();
   }
 
   public function testDeleteReturnErrorForEmptySettingName() {
-    expect($this->endpoint->delete(''))->isInstanceOf(ErrorResponse::class);
+    verify($this->endpoint->delete(''))->instanceOf(ErrorResponse::class);
   }
 
   public function testDeleteReturnErrorIfSettingDoesntExist() {
-    expect($this->endpoint->delete('unexistent_setting'))->isInstanceOf(ErrorResponse::class);
+    verify($this->endpoint->delete('unexistent_setting'))->instanceOf(ErrorResponse::class);
   }
 
   public function testItSetsUpMSSWithProvidedKey() {
@@ -335,7 +335,7 @@ class SettingsTest extends \MailPoetTest {
       $this->diContainer->get(ConfirmationEmailCustomizer::class)
     );
 
-    expect($this->endpoint->setKeyAndSetupMss($newKey))->isInstanceOf(SuccessResponse::class);
+    verify($this->endpoint->setKeyAndSetupMss($newKey))->instanceOf(SuccessResponse::class);
     verify($this->settings->get('mta.mailpoet_api_key'))->equals($newKey);
     verify($this->settings->get('mta_group'))->equals('mailpoet');
     verify($this->settings->get('mta.method'))->equals('MailPoet');
diff --git a/mailpoet/tests/integration/API/JSON/v1/SubscribersTest.php b/mailpoet/tests/integration/API/JSON/v1/SubscribersTest.php
index 308a750989..ab5f95f57d 100644
--- a/mailpoet/tests/integration/API/JSON/v1/SubscribersTest.php
+++ b/mailpoet/tests/integration/API/JSON/v1/SubscribersTest.php
@@ -905,7 +905,7 @@ class SubscribersTest extends \MailPoetTest {
 
     $didSubscribe = $this->subscribersRepository->findOneBy(['email' => 'toto@mailpoet.com']);
     verify($didSubscribe)->null();
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->status)->equals(APIResponse::STATUS_BAD_REQUEST);
     verify($response->errors[0]['message'])->equals($expectedErrorMessage);
   }
@@ -1043,8 +1043,8 @@ class SubscribersTest extends \MailPoetTest {
 
     verify($response->status)->equals(APIResponse::STATUS_OK);
     verify($response->meta['count'])->equals(2);
-    expect($subscriberTag1)->isInstanceOf(SubscriberTagEntity::class);
-    expect($subscriberTag2)->isInstanceOf(SubscriberTagEntity::class);
+    verify($subscriberTag1)->instanceOf(SubscriberTagEntity::class);
+    verify($subscriberTag2)->instanceOf(SubscriberTagEntity::class);
 
     // Testing that adding the same tag again does not return an error
     $response = $this->endpoint->bulkAction($bulkActionData);
diff --git a/mailpoet/tests/integration/Cron/Workers/InactiveSubscribersTest.php b/mailpoet/tests/integration/Cron/Workers/InactiveSubscribersTest.php
index b512113cc5..3619543674 100644
--- a/mailpoet/tests/integration/Cron/Workers/InactiveSubscribersTest.php
+++ b/mailpoet/tests/integration/Cron/Workers/InactiveSubscribersTest.php
@@ -48,7 +48,7 @@ class InactiveSubscribersTest extends \MailPoetTest {
     );
 
     $this->assertInstanceOf(ScheduledTaskEntity::class, $task);
-    expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+    verify($task)->instanceOf(ScheduledTaskEntity::class);
     expect($task->getScheduledAt())->greaterThan(new Carbon());
   }
 
@@ -85,7 +85,7 @@ class InactiveSubscribersTest extends \MailPoetTest {
     );
 
     $this->assertInstanceOf(ScheduledTaskEntity::class, $task);
-    expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+    verify($task)->instanceOf(ScheduledTaskEntity::class);
     expect($task->getScheduledAt())->greaterThan(new Carbon());
   }
 
diff --git a/mailpoet/tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php b/mailpoet/tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
index 0b171f8f07..175e93f3e9 100644
--- a/mailpoet/tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
+++ b/mailpoet/tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
@@ -112,12 +112,12 @@ class NewsletterTest extends \MailPoetTest {
     $newsletterEntity->setStatus(NewsletterEntity::STATUS_ACTIVE);
     $this->newslettersRepository->persist($newsletterEntity);
     $this->newslettersRepository->flush();
-    expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->isInstanceOf(NewsletterEntity::class);
+    verify($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->instanceOf(NewsletterEntity::class);
 
     $newsletterEntity->setStatus(NewsletterEntity::STATUS_SENDING);
     $this->newslettersRepository->persist($newsletterEntity);
     $this->newslettersRepository->flush();
-    expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->isInstanceOf(NewsletterEntity::class);
+    verify($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->instanceOf(NewsletterEntity::class);
   }
 
   public function testItDoesNotGetDeletedNewsletter() {
@@ -146,12 +146,12 @@ class NewsletterTest extends \MailPoetTest {
     $parentNewsletterEntity->setStatus(NewsletterEntity::STATUS_ACTIVE);
     $this->newslettersRepository->persist($parentNewsletterEntity);
     $this->newslettersRepository->flush();
-    expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->isInstanceOf(NewsletterEntity::class);
+    verify($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->instanceOf(NewsletterEntity::class);
 
     $parentNewsletterEntity->setStatus(NewsletterEntity::STATUS_SENDING);
     $this->newslettersRepository->persist($parentNewsletterEntity);
     $this->newslettersRepository->flush();
-    expect($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->isInstanceOf(NewsletterEntity::class);
+    verify($this->newsletterTask->getNewsletterFromQueue($this->sendingTask))->instanceOf(NewsletterEntity::class);
   }
 
   public function testItDoesNotGetDeletedNewsletterWhenParentNewsletterIsDeleted() {
@@ -248,7 +248,7 @@ class NewsletterTest extends \MailPoetTest {
     $newsletterTask = new NewsletterTask(new WPFunctions, $postsTask);
     $result = $newsletterTask->preProcessNewsletter($this->newsletter, $this->sendingTask);
     $newsletterPost = $newsletterPostRepository->findOneBy(['newsletter' => $this->newsletter->getId()]);
-    expect($newsletterPost)->isInstanceOf(NewsletterPostEntity::class);
+    verify($newsletterPost)->instanceOf(NewsletterPostEntity::class);
     verify($result)->notEquals(false);
     $this->assertInstanceOf(NewsletterPostEntity::class, $newsletterPost);
     verify($newsletterPost->getPostId())->equals('10');
diff --git a/mailpoet/tests/integration/Cron/Workers/SubscribersLifetimeEmailCountTest.php b/mailpoet/tests/integration/Cron/Workers/SubscribersLifetimeEmailCountTest.php
index d540b31db7..e773b27ed4 100644
--- a/mailpoet/tests/integration/Cron/Workers/SubscribersLifetimeEmailCountTest.php
+++ b/mailpoet/tests/integration/Cron/Workers/SubscribersLifetimeEmailCountTest.php
@@ -145,7 +145,7 @@ class SubscribersLifetimeEmailCountTest extends \MailPoetTest {
     );
 
     $this->assertInstanceOf(ScheduledTaskEntity::class, $task);
-    expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+    verify($task)->instanceOf(ScheduledTaskEntity::class);
     expect($task->getScheduledAt())->greaterThan(new Carbon());
   }
 
diff --git a/mailpoet/tests/integration/Cron/Workers/SubscribersStatsReportTest.php b/mailpoet/tests/integration/Cron/Workers/SubscribersStatsReportTest.php
index 1f1ec73493..9bfc12dfcd 100644
--- a/mailpoet/tests/integration/Cron/Workers/SubscribersStatsReportTest.php
+++ b/mailpoet/tests/integration/Cron/Workers/SubscribersStatsReportTest.php
@@ -104,11 +104,11 @@ class SubscribersStatsReportTest extends \MailPoetTest {
       ->method('currentTime')
       ->willReturn($time);
     $result = $this->worker->getNextRunDate();
-    expect($result)->isInstanceOf(Carbon::class);
+    verify($result)->instanceOf(Carbon::class);
     expect($result->getTimestamp())->greaterThan($time);
     expect($result->getTimestamp())->lessThan($time + $maxExpectedScheduleInterval);
     $result2 = $this->worker->getNextRunDate();
-    expect($result2)->isInstanceOf(Carbon::class);
+    verify($result2)->instanceOf(Carbon::class);
     expect($result2->getTimestamp())->greaterThan($time);
     expect($result2->getTimestamp())->lessThan($time + $maxExpectedScheduleInterval);
     verify($result2->getTimestamp())->notEquals($result->getTimestamp());
diff --git a/mailpoet/tests/integration/Doctrine/ConfigurationFactoryTest.php b/mailpoet/tests/integration/Doctrine/ConfigurationFactoryTest.php
index 50d9caff70..2a4b90eade 100644
--- a/mailpoet/tests/integration/Doctrine/ConfigurationFactoryTest.php
+++ b/mailpoet/tests/integration/Doctrine/ConfigurationFactoryTest.php
@@ -17,17 +17,17 @@ class ConfigurationFactoryTest extends \MailPoetTest {
     $configurationFactory = new ConfigurationFactory(new AnnotationReaderProvider(), false);
     $configuration = $configurationFactory->createConfiguration();
 
-    expect($configuration)->isInstanceOf(Configuration::class);
-    expect($configuration->getNamingStrategy())->isInstanceOf(UnderscoreNamingStrategy::class);
+    verify($configuration)->instanceOf(Configuration::class);
+    verify($configuration->getNamingStrategy())->instanceOf(UnderscoreNamingStrategy::class);
 
     // metadata
     verify($configuration->getClassMetadataFactoryName())->equals(TablePrefixMetadataFactory::class);
-    expect($configuration->getMetadataCache())->isInstanceOf(PSRMetadataCache::class);
-    expect($configuration->getMetadataDriverImpl())->isInstanceOf(AnnotationDriver::class);
+    verify($configuration->getMetadataCache())->instanceOf(PSRMetadataCache::class);
+    verify($configuration->getMetadataDriverImpl())->instanceOf(AnnotationDriver::class);
 
     // cache
-    expect($configuration->getQueryCacheImpl())->isInstanceOf(ArrayCache::class);
-    expect($configuration->getResultCacheImpl())->isInstanceOf(ArrayCache::class);
+    verify($configuration->getQueryCacheImpl())->instanceOf(ArrayCache::class);
+    verify($configuration->getResultCacheImpl())->instanceOf(ArrayCache::class);
 
     // proxies
     verify(realpath($configuration->getProxyDir()))->equals(realpath(__DIR__ . '/../../../generated/doctrine-proxies'));
diff --git a/mailpoet/tests/integration/Doctrine/ConnectionFactoryTest.php b/mailpoet/tests/integration/Doctrine/ConnectionFactoryTest.php
index 23afc4b147..b729926df5 100644
--- a/mailpoet/tests/integration/Doctrine/ConnectionFactoryTest.php
+++ b/mailpoet/tests/integration/Doctrine/ConnectionFactoryTest.php
@@ -28,10 +28,10 @@ class ConnectionFactoryTest extends \MailPoetTest {
     $connectionFactory = new ConnectionFactory();
     $connection = $connectionFactory->createConnection();
 
-    expect($connection)->isInstanceOf(SerializableConnection::class);
-    expect($connection->getWrappedConnection())->isInstanceOf(PDO::class);
-    expect($connection->getDriver())->isInstanceOf(PDOMySql\Driver::class);
-    expect($connection->getDatabasePlatform())->isInstanceOf(MySqlPlatform::class);
+    verify($connection)->instanceOf(SerializableConnection::class);
+    verify($connection->getWrappedConnection())->instanceOf(PDO::class);
+    verify($connection->getDriver())->instanceOf(PDOMySql\Driver::class);
+    verify($connection->getDatabasePlatform())->instanceOf(MySqlPlatform::class);
     $params = $connection->getParams();
     verify($params['host'])->equals(Env::$dbHost);
     expect($params)->notContains('unix_socket');
@@ -40,8 +40,8 @@ class ConnectionFactoryTest extends \MailPoetTest {
     verify($params['charset'])->equals(Env::$dbCharset);
     verify($connection->getDatabase())->equals(Env::$dbName);
 
-    expect(Type::getType(JsonType::NAME))->isInstanceOf(JsonType::class);
-    expect(Type::getType(JsonOrSerializedType::NAME))->isInstanceOf(JsonOrSerializedType::class);
+    verify(Type::getType(JsonType::NAME))->instanceOf(JsonType::class);
+    verify(Type::getType(JsonOrSerializedType::NAME))->instanceOf(JsonOrSerializedType::class);
   }
 
   public function testItSetsUpPort() {
@@ -92,7 +92,7 @@ class ConnectionFactoryTest extends \MailPoetTest {
     Env::$dbHost = '::ffff:' . gethostbyname($this->envBackup['db_host']);
     $connectionFactory = new ConnectionFactory();
     $connection = $connectionFactory->createConnection();
-    expect($connection->getWrappedConnection())->isInstanceOf(PDO::class);
+    verify($connection->getWrappedConnection())->instanceOf(PDO::class);
     verify($connection->executeQuery('SELECT "abc"')->fetchOne())->same('abc');
   }
 
diff --git a/mailpoet/tests/integration/Doctrine/Types/JsonTypesTest.php b/mailpoet/tests/integration/Doctrine/Types/JsonTypesTest.php
index 6e37bf65e5..59bf90745c 100644
--- a/mailpoet/tests/integration/Doctrine/Types/JsonTypesTest.php
+++ b/mailpoet/tests/integration/Doctrine/Types/JsonTypesTest.php
@@ -151,7 +151,7 @@ class JsonTypesTest extends \MailPoetTest {
     } catch (Exception $e) {
       $exception = $e;
     }
-    expect($exception)->isInstanceOf(RuntimeException::class);
+    verify($exception)->instanceOf(RuntimeException::class);
   }
 
   public function testItDoesNotLoadInvalidData() {
@@ -169,7 +169,7 @@ class JsonTypesTest extends \MailPoetTest {
     } catch (Exception $e) {
       $exception = $e;
     }
-    expect($exception)->isInstanceOf(RuntimeException::class);
+    verify($exception)->instanceOf(RuntimeException::class);
   }
 
   public function _after() {
diff --git a/mailpoet/tests/integration/Form/FormsRepositoryTest.php b/mailpoet/tests/integration/Form/FormsRepositoryTest.php
index 343fc385c1..560fcf17d3 100644
--- a/mailpoet/tests/integration/Form/FormsRepositoryTest.php
+++ b/mailpoet/tests/integration/Form/FormsRepositoryTest.php
@@ -15,7 +15,7 @@ class FormsRepositoryTest extends \MailPoetTest {
 
   public function testItCanDeleteForm() {
     $form = $this->createForm('Form 1');
-    expect($this->repository->findOneById($form->getId()))->isInstanceOf(FormEntity::class);
+    verify($this->repository->findOneById($form->getId()))->instanceOf(FormEntity::class);
     $this->repository->delete($form);
     verify($form->getId())->null();
   }
diff --git a/mailpoet/tests/integration/Mailer/Methods/AmazonSESTest.php b/mailpoet/tests/integration/Mailer/Methods/AmazonSESTest.php
index b038a19d8e..4fffdfbbf6 100644
--- a/mailpoet/tests/integration/Mailer/Methods/AmazonSESTest.php
+++ b/mailpoet/tests/integration/Mailer/Methods/AmazonSESTest.php
@@ -235,7 +235,7 @@ class AmazonSESTest extends \MailPoetTest {
     $this->mailer->sender['from_name_email'] = 'invalid';
     $result = $this->mailer->send($this->newsletter, 'test@example.com');
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString("Missing final '@domain'");
   }
 
@@ -252,7 +252,7 @@ class AmazonSESTest extends \MailPoetTest {
       $blacklistedSubscriber
     );
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString('AmazonSES has returned an unknown error.');
   }
 
diff --git a/mailpoet/tests/integration/Mailer/Methods/MailPoetAPITest.php b/mailpoet/tests/integration/Mailer/Methods/MailPoetAPITest.php
index fcf3359d05..b6fae98377 100644
--- a/mailpoet/tests/integration/Mailer/Methods/MailPoetAPITest.php
+++ b/mailpoet/tests/integration/Mailer/Methods/MailPoetAPITest.php
@@ -226,7 +226,7 @@ class MailPoetAPITest extends \MailPoetTest {
     );
     $result = $this->mailer->send($this->newsletter, $this->subscriber);
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getOperation())->equals(MailerError::OPERATION_CONNECT);
   }
 
@@ -242,7 +242,7 @@ class MailPoetAPITest extends \MailPoetTest {
     );
     $result = $this->mailer->send($this->newsletter, $this->subscriber);
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getOperation())->equals(MailerError::OPERATION_SEND);
   }
 
@@ -258,7 +258,7 @@ class MailPoetAPITest extends \MailPoetTest {
     );
     $result = $this->mailer->send($this->newsletter, $this->subscriber);
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
   }
 
   public function testFormatPayloadError() {
@@ -273,7 +273,7 @@ class MailPoetAPITest extends \MailPoetTest {
     );
     $result = $this->mailer->send([$this->newsletter, $this->newsletter], ['a@example.com', 'c d <b@example.com>']);
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getOperation())->equals(MailerError::OPERATION_SEND);
   }
 
@@ -289,7 +289,7 @@ class MailPoetAPITest extends \MailPoetTest {
     );
     $result = $this->mailer->send([$this->newsletter, $this->newsletter], ['a@example.com', 'c d <b@example.com>']);
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getOperation())->equals(MailerError::OPERATION_SEND);
   }
 
@@ -336,7 +336,7 @@ class MailPoetAPITest extends \MailPoetTest {
       $blacklistedSubscriber
     );
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString('unknown error');
     verify($result['error']->getMessage())->stringContainsString('MailPoet has returned an unknown error.');
   }
@@ -362,7 +362,7 @@ class MailPoetAPITest extends \MailPoetTest {
       ['good@example.com', $blacklistedSubscriber, 'good2@example.com']
     );
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString('unknown error');
     verify($result['error']->getMessage())->stringContainsString('MailPoet has returned an unknown error.');
   }
diff --git a/mailpoet/tests/integration/Mailer/Methods/PHPMailTest.php b/mailpoet/tests/integration/Mailer/Methods/PHPMailTest.php
index 4ce5f5830a..2bd31310b6 100644
--- a/mailpoet/tests/integration/Mailer/Methods/PHPMailTest.php
+++ b/mailpoet/tests/integration/Mailer/Methods/PHPMailTest.php
@@ -53,7 +53,7 @@ class PHPMailTest extends \MailPoetTest {
 
   public function testItCanBuildMailer() {
     $mailer = $this->mailer->buildMailer();
-    expect($mailer)->isInstanceOf(PHPMailer::class);
+    verify($mailer)->instanceOf(PHPMailer::class);
 
     // uses PHP's mail() function
     verify($mailer->Mailer)->equals('mail'); // phpcs:ignore Squiz.NamingConventions.ValidVariableName.MemberNotCamelCaps
@@ -143,7 +143,7 @@ class PHPMailTest extends \MailPoetTest {
       $blacklistedSubscriber
     );
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString('PHPMail has returned an unknown error.');
   }
 
diff --git a/mailpoet/tests/integration/Mailer/Methods/SMTPTest.php b/mailpoet/tests/integration/Mailer/Methods/SMTPTest.php
index 8ac3ae7e67..bda9080f70 100644
--- a/mailpoet/tests/integration/Mailer/Methods/SMTPTest.php
+++ b/mailpoet/tests/integration/Mailer/Methods/SMTPTest.php
@@ -190,7 +190,7 @@ class SMTPTest extends \MailPoetTest {
       $blacklistedSubscriber
     );
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString('SMTP has returned an unknown error.');
   }
 
diff --git a/mailpoet/tests/integration/Mailer/Methods/SendGridTest.php b/mailpoet/tests/integration/Mailer/Methods/SendGridTest.php
index a2678b45c2..e42cf5f348 100644
--- a/mailpoet/tests/integration/Mailer/Methods/SendGridTest.php
+++ b/mailpoet/tests/integration/Mailer/Methods/SendGridTest.php
@@ -109,7 +109,7 @@ class SendGridTest extends \MailPoetTest {
       $blacklistedSubscriber
     );
     verify($result['response'])->false();
-    expect($result['error'])->isInstanceOf(MailerError::class);
+    verify($result['error'])->instanceOf(MailerError::class);
     verify($result['error']->getMessage())->stringContainsString('SendGrid has returned an unknown error.');
   }
 
diff --git a/mailpoet/tests/integration/Migrator/TestMigrations/App/Migration_20221023_080348.php b/mailpoet/tests/integration/Migrator/TestMigrations/App/Migration_20221023_080348.php
index d0e2a312bb..08e7382aee 100644
--- a/mailpoet/tests/integration/Migrator/TestMigrations/App/Migration_20221023_080348.php
+++ b/mailpoet/tests/integration/Migrator/TestMigrations/App/Migration_20221023_080348.php
@@ -10,7 +10,7 @@ use MailPoetVendor\Doctrine\ORM\EntityManager;
 class Migration_20221023_080348 extends AppMigration {
   public function run(): void {
     echo 'Migration run called!';
-    expect($this->entityManager)->isInstanceOf(EntityManager::class);
-    expect($this->container)->isInstanceOf(ContainerWrapper::class);
+    verify($this->entityManager)->instanceOf(EntityManager::class);
+    verify($this->container)->instanceOf(ContainerWrapper::class);
   }
 }
diff --git a/mailpoet/tests/integration/Migrator/TestMigrations/Db/Migration_20221024_080348.php b/mailpoet/tests/integration/Migrator/TestMigrations/Db/Migration_20221024_080348.php
index 32f906ffa1..8f62667a4c 100644
--- a/mailpoet/tests/integration/Migrator/TestMigrations/Db/Migration_20221024_080348.php
+++ b/mailpoet/tests/integration/Migrator/TestMigrations/Db/Migration_20221024_080348.php
@@ -9,6 +9,6 @@ use MailPoetVendor\Doctrine\DBAL\Connection;
 class Migration_20221024_080348 extends DbMigration {
   public function run(): void {
     echo 'Migration run called!';
-    expect($this->connection)->isInstanceOf(Connection::class);
+    verify($this->connection)->instanceOf(Connection::class);
   }
 }
diff --git a/mailpoet/tests/integration/Models/NewsletterTest.php b/mailpoet/tests/integration/Models/NewsletterTest.php
index d19e26eead..3cd2daa7ca 100644
--- a/mailpoet/tests/integration/Models/NewsletterTest.php
+++ b/mailpoet/tests/integration/Models/NewsletterTest.php
@@ -140,7 +140,7 @@ class NewsletterTest extends \MailPoetTest {
     $newsletter->parentId = $parentNewsletter->id;
     $newsletter->save();
     $parent = $newsletter->parent()->findOne();
-    expect($parent)->isInstanceOf('MailPoet\Models\Newsletter');
+    verify($parent)->instanceOf('MailPoet\Models\Newsletter');
     verify($parent->id)->equals($parentNewsletter->id);
   }
 
diff --git a/mailpoet/tests/integration/Newsletter/NewsletterRepositoryTest.php b/mailpoet/tests/integration/Newsletter/NewsletterRepositoryTest.php
index 8b9a6790e1..8aea3a3d1a 100644
--- a/mailpoet/tests/integration/Newsletter/NewsletterRepositoryTest.php
+++ b/mailpoet/tests/integration/Newsletter/NewsletterRepositoryTest.php
@@ -253,8 +253,8 @@ class NewsletterRepositoryTest extends \MailPoetTest {
     $newsletter2->setWpPostId($post2Id);
     $newsletter3 = $this->createNewsletter(NewsletterEntity::TYPE_STANDARD, NewsletterEntity::STATUS_SENDING);
 
-    expect($this->wp->getPost($post1Id))->isInstanceOf(\WP_Post::class);
-    expect($this->wp->getPost($post2Id))->isInstanceOf(\WP_Post::class);
+    verify($this->wp->getPost($post1Id))->instanceOf(\WP_Post::class);
+    verify($this->wp->getPost($post2Id))->instanceOf(\WP_Post::class);
 
     $this->entityManager->flush();
     $this->entityManager->clear();
diff --git a/mailpoet/tests/integration/Newsletter/Sending/ScheduledTasksRepositoryTest.php b/mailpoet/tests/integration/Newsletter/Sending/ScheduledTasksRepositoryTest.php
index 42da8acc25..4c3422ab5b 100644
--- a/mailpoet/tests/integration/Newsletter/Sending/ScheduledTasksRepositoryTest.php
+++ b/mailpoet/tests/integration/Newsletter/Sending/ScheduledTasksRepositoryTest.php
@@ -127,10 +127,10 @@ class ScheduledTasksRepositoryTest extends \MailPoetTest {
     $this->assertContains(SendingTask::TASK_TYPE, $types);
     $this->assertContains(Bounce::TASK_TYPE, $types);
     verify(is_int($data[1]->getPriority()))->true();
-    expect($data[1]->getUpdatedAt())->isInstanceOf(\DateTimeInterface::class);
+    verify($data[1]->getUpdatedAt())->instanceOf(\DateTimeInterface::class);
     verify($data[1]->getStatus())->notEmpty();
-    expect($data[0])->isInstanceOf(ScheduledTaskEntity::class);
-    expect($data[1])->isInstanceOf(ScheduledTaskEntity::class);
+    verify($data[0])->instanceOf(ScheduledTaskEntity::class);
+    verify($data[1])->instanceOf(ScheduledTaskEntity::class);
   }
 
   public function testItCanFilterTasksByType() {
diff --git a/mailpoet/tests/integration/Segments/DynamicSegments/FilterDataMapperTest.php b/mailpoet/tests/integration/Segments/DynamicSegments/FilterDataMapperTest.php
index e50be6b464..2332557d02 100644
--- a/mailpoet/tests/integration/Segments/DynamicSegments/FilterDataMapperTest.php
+++ b/mailpoet/tests/integration/Segments/DynamicSegments/FilterDataMapperTest.php
@@ -66,7 +66,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_EMAIL);
     verify($filter->getAction())->equals(EmailAction::ACTION_OPENED);
     verify($filter->getData())->equals([
@@ -88,7 +88,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_EMAIL);
     verify($filter->getAction())->equals(EmailAction::ACTION_CLICKED);
     verify($filter->getData())->equals([
@@ -112,7 +112,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_EMAIL);
     verify($filter->getAction())->equals(EmailAction::ACTION_CLICKED);
     verify($filter->getData())->equals([
@@ -179,7 +179,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals('userRole');
     verify($filter->getData())->equals([
@@ -211,7 +211,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals(WooCommerceCategory::ACTION_CATEGORY);
     verify($filter->getData())->equals([
@@ -267,7 +267,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals(WooCommerceProduct::ACTION_PRODUCT);
     verify($filter->getData())->equals([
@@ -299,7 +299,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_EMAIL);
     verify($filter->getAction())->equals(EmailOpensAbsoluteCountAction::TYPE);
     verify($filter->getData())->equals([
@@ -322,7 +322,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_EMAIL);
     verify($filter->getAction())->equals(EmailActionClickAny::TYPE);
     verify($filter->getData())->equals([
@@ -343,7 +343,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_EMAIL);
     verify($filter->getAction())->equals(EmailOpensAbsoluteCountAction::TYPE);
     verify($filter->getData())->equals([
@@ -397,7 +397,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     unset($expectedResult['some_mess'], $expectedResult['segmentType'], $expectedResult['action']);
     $expectedResult['connect'] = DynamicSegmentFilterData::CONNECT_TYPE_AND;
 
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals(WooCommerceNumberOfOrders::ACTION_NUMBER_OF_ORDERS);
     verify($filter->getData())->equals($expectedResult);
@@ -437,7 +437,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     unset($expectedResult['some_mess'], $expectedResult['segmentType'], $expectedResult['action']);
     $expectedResult['connect'] = DynamicSegmentFilterData::CONNECT_TYPE_AND;
 
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals(WooCommerceSingleOrderValue::ACTION_SINGLE_ORDER_VALUE);
     verify($filter->getData())->equals($expectedResult);
@@ -469,7 +469,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE_SUBSCRIPTION);
     verify($filter->getAction())->equals(WooCommerceSubscription::ACTION_HAS_ACTIVE);
     verify($filter->getData())->equals([
@@ -526,7 +526,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals(WooCommerceCountry::ACTION_CUSTOMER_COUNTRY);
     verify($filter->getData())->equals([
@@ -568,7 +568,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals(SubscriberScore::TYPE);
     verify($filter->getData())->equals([
@@ -600,7 +600,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals(SubscriberSegment::TYPE);
     verify($filter->getData())->equals([
@@ -657,7 +657,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals(MailPoetCustomFields::TYPE);
     verify($filter->getData())->equals([
@@ -694,7 +694,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals(SubscriberTag::TYPE);
     verify($filter->getData())->equals([
@@ -717,7 +717,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals(SubscriberTextField::FIRST_NAME);
     verify($filter->getData())->equals([
@@ -751,7 +751,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals(SubscriberSubscribedViaForm::TYPE);
     verify($filter->getData())->equals([
@@ -797,7 +797,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_AUTOMATIONS);
     verify($filter->getAction())->equals('enteredAutomation');
     verify($filter->getData())->equals([
@@ -820,7 +820,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_AUTOMATIONS);
     verify($filter->getAction())->equals('exitedAutomation');
     verify($filter->getData())->equals([
@@ -892,7 +892,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals('numberOfReviews');
     verify($filter->getData())->equals([
@@ -919,7 +919,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_WOOCOMMERCE);
     verify($filter->getAction())->equals('usedCouponCode');
     verify($filter->getData())->equals([
@@ -946,7 +946,7 @@ class FilterDataMapperTest extends \MailPoetTest {
     expect($filters)->count(1);
     $filter = reset($filters);
     $this->assertInstanceOf(DynamicSegmentFilterData::class, $filter);
-    expect($filter)->isInstanceOf(DynamicSegmentFilterData::class);
+    verify($filter)->instanceOf(DynamicSegmentFilterData::class);
     verify($filter->getFilterType())->equals(DynamicSegmentFilterData::TYPE_USER_ROLE);
     verify($filter->getAction())->equals($action);
     verify($filter->getData())->equals([
diff --git a/mailpoet/tests/integration/Segments/SegmentsRepositoryTest.php b/mailpoet/tests/integration/Segments/SegmentsRepositoryTest.php
index 05875463bc..c539db778a 100644
--- a/mailpoet/tests/integration/Segments/SegmentsRepositoryTest.php
+++ b/mailpoet/tests/integration/Segments/SegmentsRepositoryTest.php
@@ -33,8 +33,8 @@ class SegmentsRepositoryTest extends \MailPoetTest {
     $this->entityManager->refresh($segment1);
     $this->entityManager->refresh($segment2);
     verify($result)->equals(2);
-    expect($segment1->getDeletedAt())->isInstanceOf(\DateTimeInterface::class);
-    expect($segment2->getDeletedAt())->isInstanceOf(\DateTimeInterface::class);
+    verify($segment1->getDeletedAt())->instanceOf(\DateTimeInterface::class);
+    verify($segment2->getDeletedAt())->instanceOf(\DateTimeInterface::class);
   }
 
   public function testItCanBulkTrashDynamicSegments(): void {
@@ -45,8 +45,8 @@ class SegmentsRepositoryTest extends \MailPoetTest {
     $this->entityManager->refresh($segment1);
     $this->entityManager->refresh($segment2);
     verify($result)->equals(2);
-    expect($segment1->getDeletedAt())->isInstanceOf(\DateTimeInterface::class);
-    expect($segment2->getDeletedAt())->isInstanceOf(\DateTimeInterface::class);
+    verify($segment1->getDeletedAt())->instanceOf(\DateTimeInterface::class);
+    verify($segment2->getDeletedAt())->instanceOf(\DateTimeInterface::class);
   }
 
   public function testItSkipTrashingForActivelyUsedDefaultSegments(): void {
@@ -59,7 +59,7 @@ class SegmentsRepositoryTest extends \MailPoetTest {
     $this->entityManager->refresh($segment2);
     verify($result)->equals(1);
     verify($segment1->getDeletedAt())->null();
-    expect($segment2->getDeletedAt())->isInstanceOf(\DateTimeInterface::class);
+    verify($segment2->getDeletedAt())->instanceOf(\DateTimeInterface::class);
   }
 
   public function testItSkipTrashingForActivelyUsedDynamicSegments(): void {
@@ -71,7 +71,7 @@ class SegmentsRepositoryTest extends \MailPoetTest {
     $this->entityManager->refresh($segment1);
     $this->entityManager->refresh($segment2);
     verify($result)->equals(1);
-    expect($segment1->getDeletedAt())->isInstanceOf(\DateTimeInterface::class);
+    verify($segment1->getDeletedAt())->instanceOf(\DateTimeInterface::class);
     verify($segment2->getDeletedAt())->null();
   }
 
diff --git a/mailpoet/tests/integration/Settings/SettingsChangeHandlerTest.php b/mailpoet/tests/integration/Settings/SettingsChangeHandlerTest.php
index 6016893005..98a1c100d5 100644
--- a/mailpoet/tests/integration/Settings/SettingsChangeHandlerTest.php
+++ b/mailpoet/tests/integration/Settings/SettingsChangeHandlerTest.php
@@ -47,7 +47,7 @@ class SettingsChangeHandlerTest extends \MailPoetTest {
     verify($task)->null();
     $this->settingsChangeHandler->onSubscribeOldWoocommerceCustomersChange();
     $task = $this->getScheduledTaskByType(WooCommerceSync::TASK_TYPE);
-    expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+    verify($task)->instanceOf(ScheduledTaskEntity::class);
   }
 
   public function testItReschedulesScheduledTaskForInactiveSubscribers(): void {
@@ -70,7 +70,7 @@ class SettingsChangeHandlerTest extends \MailPoetTest {
     verify($task)->null();
     $this->settingsChangeHandler->onInactiveSubscribersIntervalChange();
     $task = $this->getScheduledTaskByType(InactiveSubscribers::TASK_TYPE);
-    expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+    verify($task)->instanceOf(ScheduledTaskEntity::class);
   }
 
   private function createScheduledTask(string $type): ScheduledTaskEntity {
diff --git a/mailpoet/tests/integration/Statistics/StatisticsFormsRepositoryTest.php b/mailpoet/tests/integration/Statistics/StatisticsFormsRepositoryTest.php
index 80df5f5792..33743e1478 100644
--- a/mailpoet/tests/integration/Statistics/StatisticsFormsRepositoryTest.php
+++ b/mailpoet/tests/integration/Statistics/StatisticsFormsRepositoryTest.php
@@ -22,7 +22,7 @@ class StatisticsFormsRepositoryTest extends \MailPoetTest {
     $this->assertInstanceOf(StatisticsFormEntity::class, $record);
     verify($record->getForm())->equals($form);
     verify($record->getSubscriber())->equals($subscriber);
-    expect($this->repository->findOneBy(['form' => $form, 'subscriber' => $subscriber]))->isInstanceOf(StatisticsFormEntity::class);
+    verify($this->repository->findOneBy(['form' => $form, 'subscriber' => $subscriber]))->instanceOf(StatisticsFormEntity::class);
   }
 
   public function testItDoesNotOverrideStats(): void {
diff --git a/mailpoet/tests/integration/Subscribers/ConfirmationEmailCustomizerTest.php b/mailpoet/tests/integration/Subscribers/ConfirmationEmailCustomizerTest.php
index dd4c98058a..1575c3ce8a 100644
--- a/mailpoet/tests/integration/Subscribers/ConfirmationEmailCustomizerTest.php
+++ b/mailpoet/tests/integration/Subscribers/ConfirmationEmailCustomizerTest.php
@@ -37,7 +37,7 @@ class ConfirmationEmailCustomizerTest extends \MailPoetTest {
     verify($this->settings->get(ConfirmationEmailCustomizer::SETTING_EMAIL_ID, false))->equals(false);
     $newsletter = $controller->getNewsletter();
 
-    expect($newsletter)->isInstanceOf(NewsletterEntity::class);
+    verify($newsletter)->instanceOf(NewsletterEntity::class);
 
     verify($this->settings->get(ConfirmationEmailCustomizer::SETTING_EMAIL_ID, false))->notEquals(false);
   }
@@ -48,7 +48,7 @@ class ConfirmationEmailCustomizerTest extends \MailPoetTest {
     $controller = $this->generateController();
     $newsletter = $controller->getNewsletter();
 
-    expect($newsletter)->isInstanceOf(NewsletterEntity::class);
+    verify($newsletter)->instanceOf(NewsletterEntity::class);
 
     verify($newsletter->getId())->notEquals(5);
 
diff --git a/mailpoet/tests/integration/Subscribers/ImportExport/Import/ImportTest.php b/mailpoet/tests/integration/Subscribers/ImportExport/Import/ImportTest.php
index 5dad626c58..3343e2e58e 100644
--- a/mailpoet/tests/integration/Subscribers/ImportExport/Import/ImportTest.php
+++ b/mailpoet/tests/integration/Subscribers/ImportExport/Import/ImportTest.php
@@ -572,12 +572,12 @@ class ImportTest extends \MailPoetTest {
         'subscriber' => $dbSubscriber,
         'segment' => $this->segment1->getId(),
       ]);
-      expect($subscriberSegment1)->isInstanceOf(SubscriberSegmentEntity::class);
+      verify($subscriberSegment1)->instanceOf(SubscriberSegmentEntity::class);
       $subscriberSegment2 = $this->subscriberSegmentRepository->findOneBy([
         'subscriber' => $dbSubscriber,
         'segment' => $this->segment2->getId(),
       ]);
-      expect($subscriberSegment2)->isInstanceOf(SubscriberSegmentEntity::class);
+      verify($subscriberSegment2)->instanceOf(SubscriberSegmentEntity::class);
     }
   }
 
@@ -607,12 +607,12 @@ class ImportTest extends \MailPoetTest {
         'subscriber' => $dbSubscriber,
         'tag' => $this->tag1,
       ]);
-      expect($subscriberTag)->isInstanceOf(SubscriberTagEntity::class);
+      verify($subscriberTag)->instanceOf(SubscriberTagEntity::class);
       $subscriberTag = $this->subscribersTagRepository->findOneBy([
         'subscriber' => $dbSubscriber,
         'tag' => $tag2,
       ]);
-      expect($subscriberTag)->isInstanceOf(SubscriberTagEntity::class);
+      verify($subscriberTag)->instanceOf(SubscriberTagEntity::class);
     }
   }
 
@@ -776,7 +776,7 @@ class ImportTest extends \MailPoetTest {
         'subscriber' => $dbSubscriber,
         'segment' => $this->testData['segments'][0],
       ]);
-      expect($subscriberSegment)->isInstanceOf(SubscriberSegmentEntity::class);
+      verify($subscriberSegment)->instanceOf(SubscriberSegmentEntity::class);
     }
   }
 
diff --git a/mailpoet/tests/integration/Subscribers/SubscriberActionsTest.php b/mailpoet/tests/integration/Subscribers/SubscriberActionsTest.php
index a83d542c35..63b527f4df 100644
--- a/mailpoet/tests/integration/Subscribers/SubscriberActionsTest.php
+++ b/mailpoet/tests/integration/Subscribers/SubscriberActionsTest.php
@@ -92,7 +92,7 @@ class SubscriberActionsTest extends \MailPoetTest {
       $newsletter,
       ScheduledTaskEntity::STATUS_SCHEDULED
     );
-    expect($scheduledNotification)->isInstanceOf(SendingQueueEntity::class);
+    verify($scheduledNotification)->instanceOf(SendingQueueEntity::class);
   }
 
   public function testItDoesNotScheduleWelcomeNotificationUponSubscriptionWhenSubscriptionConfirmationIsEnabled() {
diff --git a/mailpoet/tests/integration/Subscribers/SubscriberSubscribeControllerTest.php b/mailpoet/tests/integration/Subscribers/SubscriberSubscribeControllerTest.php
index 6503a0378a..89ce1ff52a 100644
--- a/mailpoet/tests/integration/Subscribers/SubscriberSubscribeControllerTest.php
+++ b/mailpoet/tests/integration/Subscribers/SubscriberSubscribeControllerTest.php
@@ -66,7 +66,7 @@ class SubscriberSubscribeControllerTest extends \MailPoetTest {
 
     $subscriber = $this->subscribersRepository->findOneBy(['email' => $data[$this->obfuscatedEmail]]);
     $this->assertInstanceOf(SubscriberEntity::class, $subscriber);
-    expect($subscriber)->isInstanceOf(SubscriberEntity::class);
+    verify($subscriber)->instanceOf(SubscriberEntity::class);
     verify($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
   }
 
@@ -84,7 +84,7 @@ class SubscriberSubscribeControllerTest extends \MailPoetTest {
 
     $subscriber = $this->subscribersRepository->findOneBy(['email' => $data[$this->obfuscatedEmail]]);
     $this->assertInstanceOf(SubscriberEntity::class, $subscriber);
-    expect($subscriber)->isInstanceOf(SubscriberEntity::class);
+    verify($subscriber)->instanceOf(SubscriberEntity::class);
     verify($subscriber->getStatus())->equals(SubscriberEntity::STATUS_UNCONFIRMED);
   }
 
@@ -126,13 +126,13 @@ class SubscriberSubscribeControllerTest extends \MailPoetTest {
 
     $subscriber = $this->subscribersRepository->findOneBy(['email' => $data[$this->obfuscatedEmail]]);
     $this->assertInstanceOf(SubscriberEntity::class, $subscriber);
-    expect($subscriber)->isInstanceOf(SubscriberEntity::class);
+    verify($subscriber)->instanceOf(SubscriberEntity::class);
     verify($subscriber->getStatus())->equals(SubscriberEntity::STATUS_SUBSCRIBED);
     $subscriberCustomFields = $this->subscriberCustomFieldRepository->findBy(['subscriber' => $subscriber]);
     expect($subscriberCustomFields)->count(1);
     $subscriberCustomField = reset($subscriberCustomFields);
     $this->assertInstanceOf(SubscriberCustomFieldEntity::class, $subscriberCustomField);
-    expect($subscriberCustomField)->isInstanceOf(SubscriberCustomFieldEntity::class);
+    verify($subscriberCustomField)->instanceOf(SubscriberCustomFieldEntity::class);
     verify($subscriberCustomField->getSubscriber())->equals($subscriber);
     verify($subscriberCustomField->getCustomField())->equals($customField);
     verify($subscriberCustomField->getValue())->equals($data['cf_' . $customField->getId()]);
diff --git a/mailpoet/tests/integration/Tasks/SendingTest.php b/mailpoet/tests/integration/Tasks/SendingTest.php
index 99bfd94054..ae805abe2d 100644
--- a/mailpoet/tests/integration/Tasks/SendingTest.php
+++ b/mailpoet/tests/integration/Tasks/SendingTest.php
@@ -165,7 +165,7 @@ class SendingTest extends \MailPoetTest {
     $tasks = $this->scheduledTaskRepository->findScheduledSendingTasks();
     verify($tasks)->notEmpty();
     foreach ($tasks as $task) {
-      expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+      verify($task)->instanceOf(ScheduledTaskEntity::class);
     }
 
     // if task exists but sending queue is missing, results should not contain empty (false) values
@@ -194,7 +194,7 @@ class SendingTest extends \MailPoetTest {
     $tasks = $this->scheduledTaskRepository->findRunningSendingTasks();
     verify($tasks)->notEmpty();
     foreach ($tasks as $task) {
-      expect($task)->isInstanceOf(ScheduledTaskEntity::class);
+      verify($task)->instanceOf(ScheduledTaskEntity::class);
     }
 
     // if task exists but sending queue is missing, results should not contain empty (false) values
diff --git a/mailpoet/tests/unit/API/JSON/ErrorHandlerTest.php b/mailpoet/tests/unit/API/JSON/ErrorHandlerTest.php
index 0ee24d6c43..c03cdd4169 100644
--- a/mailpoet/tests/unit/API/JSON/ErrorHandlerTest.php
+++ b/mailpoet/tests/unit/API/JSON/ErrorHandlerTest.php
@@ -38,7 +38,7 @@ class ErrorHandlerTest extends \MailPoetUnitTest {
       'key' => 'value',
     ]));
 
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->status)->equals($expectedCode);
     verify($response->errors)->equals([['error' => 'key', 'message' => 'value']]);
   }
diff --git a/mailpoet/tests/unit/API/JSON/PremiumTest.php b/mailpoet/tests/unit/API/JSON/PremiumTest.php
index 6c94fd2297..43d16c8098 100644
--- a/mailpoet/tests/unit/API/JSON/PremiumTest.php
+++ b/mailpoet/tests/unit/API/JSON/PremiumTest.php
@@ -25,7 +25,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, $wp, new DotcomHelperFunctions());
     $response = $premium->installPlugin();
-    expect($response)->isInstanceOf(SuccessResponse::class);
+    verify($response)->instanceOf(SuccessResponse::class);
   }
 
   public function testInstallationFailsWhenKeyInvalid() {
@@ -40,7 +40,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, $wp, new DotcomHelperFunctions());
     $response = $premium->installPlugin();
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->getData()['errors'][0])->same([
       'error' => 'bad_request',
       'message' => 'Premium key is not valid.',
@@ -59,7 +59,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, $wp, new DotcomHelperFunctions());
     $response = $premium->installPlugin();
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->getData()['errors'][0])->same([
       'error' => 'bad_request',
       'message' => 'Error when installing MailPoet Premium plugin.',
@@ -80,7 +80,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, $wp, new DotcomHelperFunctions());
     $response = $premium->installPlugin();
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->getData()['errors'][0])->same([
       'error' => 'bad_request',
       'message' => 'Error when installing MailPoet Premium plugin.',
@@ -98,7 +98,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, $wp, new DotcomHelperFunctions());
     $response = $premium->activatePlugin();
-    expect($response)->isInstanceOf(SuccessResponse::class);
+    verify($response)->instanceOf(SuccessResponse::class);
   }
 
   public function testActivationFailsWhenKeyInvalid() {
@@ -108,7 +108,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, new WPFunctions(), new DotcomHelperFunctions());
     $response = $premium->activatePlugin();
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->getData()['errors'][0])->same([
       'error' => 'bad_request',
       'message' => 'Premium key is not valid.',
@@ -126,7 +126,7 @@ class PremiumTest extends \MailPoetUnitTest {
 
     $premium = new Premium($servicesChecker, $wp, new DotcomHelperFunctions());
     $response = $premium->activatePlugin();
-    expect($response)->isInstanceOf(ErrorResponse::class);
+    verify($response)->instanceOf(ErrorResponse::class);
     verify($response->getData()['errors'][0])->same([
       'error' => 'bad_request',
       'message' => 'Error when activating MailPoet Premium plugin.',
diff --git a/mailpoet/tests/unit/DI/ContainerWrapperTest.php b/mailpoet/tests/unit/DI/ContainerWrapperTest.php
index 0e6e852488..6e7b4426c3 100644
--- a/mailpoet/tests/unit/DI/ContainerWrapperTest.php
+++ b/mailpoet/tests/unit/DI/ContainerWrapperTest.php
@@ -14,12 +14,12 @@ require_once __DIR__ . '/TestService.php';
 class ContainerWrapperTest extends \MailPoetUnitTest {
   public function testItCanConstruct() {
     $instance = new ContainerWrapper(new ContainerBuilder());
-    expect($instance)->isInstanceOf(ContainerWrapper::class);
-    expect($instance)->isInstanceOf(ContainerInterface::class);
+    verify($instance)->instanceOf(ContainerWrapper::class);
+    verify($instance)->instanceOf(ContainerInterface::class);
 
     $instance = new ContainerWrapper(new ContainerBuilder(), new ContainerBuilder());
-    expect($instance)->isInstanceOf(ContainerWrapper::class);
-    expect($instance)->isInstanceOf(ContainerInterface::class);
+    verify($instance)->instanceOf(ContainerWrapper::class);
+    verify($instance)->instanceOf(ContainerInterface::class);
   }
 
   public function testItProvidesPremiumContainerIfAvailable() {
@@ -27,7 +27,7 @@ class ContainerWrapperTest extends \MailPoetUnitTest {
     verify($instance->getPremiumContainer())->null();
 
     $instance = new ContainerWrapper(new ContainerBuilder(), new ContainerBuilder());
-    expect($instance->getPremiumContainer())->isInstanceOf(ContainerBuilder::class);
+    verify($instance->getPremiumContainer())->instanceOf(ContainerBuilder::class);
   }
 
   public function testItProvidesFreePluginServices() {
@@ -55,7 +55,7 @@ class ContainerWrapperTest extends \MailPoetUnitTest {
     } catch (ServiceNotFoundException $e) {
       $exception = $e;
     }
-    expect($exception)->isInstanceOf(ServiceNotFoundException::class);
+    verify($exception)->instanceOf(ServiceNotFoundException::class);
   }
 
   public function testItReturnServiceFromPremium() {
@@ -91,6 +91,6 @@ class ContainerWrapperTest extends \MailPoetUnitTest {
     } catch (ServiceNotFoundException $e) {
       $exception = $e;
     }
-    expect($exception)->isInstanceOf(ServiceNotFoundException::class);
+    verify($exception)->instanceOf(ServiceNotFoundException::class);
   }
 }
diff --git a/mailpoet/tests/unit/Form/Templates/TemplatesRepositoryTest.php b/mailpoet/tests/unit/Form/Templates/TemplatesRepositoryTest.php
index 5fa9c899eb..af6a57b2b5 100644
--- a/mailpoet/tests/unit/Form/Templates/TemplatesRepositoryTest.php
+++ b/mailpoet/tests/unit/Form/Templates/TemplatesRepositoryTest.php
@@ -24,7 +24,7 @@ class TemplatesRepositoryTest extends \MailPoetUnitTest {
 
   public function testItCanBuildFormTemplate() {
     $formEntity = $this->repository->getFormTemplate(TemplateRepository::INITIAL_FORM_TEMPLATE);
-    expect($formEntity)->isInstanceOf(FormTemplate::class);
+    verify($formEntity)->instanceOf(FormTemplate::class);
     verify($formEntity->getStyles())->notEmpty();
     verify($formEntity->getBody())->notEmpty();
     verify($formEntity->getSettings())->notEmpty();
diff --git a/mailpoet/tests/unit/Logging/LoggerFactoryTest.php b/mailpoet/tests/unit/Logging/LoggerFactoryTest.php
index 2b28f4a6a9..ebda3a3cec 100644
--- a/mailpoet/tests/unit/Logging/LoggerFactoryTest.php
+++ b/mailpoet/tests/unit/Logging/LoggerFactoryTest.php
@@ -27,7 +27,7 @@ class LoggerFactoryTest extends \MailPoetUnitTest {
 
   public function testItCreatesLogger() {
     $logger = $this->loggerFactory->getLogger('logger-name');
-    expect($logger)->isInstanceOf(\MailPoetVendor\Monolog\Logger::class);
+    verify($logger)->instanceOf(\MailPoetVendor\Monolog\Logger::class);
   }
 
   public function testItReturnsInstance() {
@@ -52,7 +52,7 @@ class LoggerFactoryTest extends \MailPoetUnitTest {
     $logger1 = $this->loggerFactory->getLogger('logger-with-handler');
     $handlers = $logger1->getHandlers();
     verify($handlers)->notEmpty();
-    expect($handlers[0])->isInstanceOf(LogHandler::class);
+    verify($handlers[0])->instanceOf(LogHandler::class);
   }
 
   public function testItSetsDefaultLoggingLevel() {
diff --git a/mailpoet/tests/unit/Mailer/Methods/ErrorMappers/MailPoetMapperTest.php b/mailpoet/tests/unit/Mailer/Methods/ErrorMappers/MailPoetMapperTest.php
index 8d86844c6f..76921a65a1 100644
--- a/mailpoet/tests/unit/Mailer/Methods/ErrorMappers/MailPoetMapperTest.php
+++ b/mailpoet/tests/unit/Mailer/Methods/ErrorMappers/MailPoetMapperTest.php
@@ -37,7 +37,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
 
   public function testCreateBlacklistError() {
     $error = $this->mapper->getBlacklistError($this->subscribers[1]);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_SOFT);
     verify($error->getMessage())->stringContainsString('unknown error');
@@ -46,7 +46,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
 
   public function testCreateConnectionError() {
     $error = $this->mapper->getConnectionError('connection error');
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_CONNECT);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->equals('connection error');
@@ -60,7 +60,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
 
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->equals('JSON input is not an array');
@@ -75,7 +75,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
 
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->stringContainsString('MailPoet Sending Service has been temporarily suspended for your site due to');
@@ -90,7 +90,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
 
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_INSUFFICIENT_PRIVILEGES);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->stringContainsString('You have reached the subscriber limit of your plan.');
@@ -105,7 +105,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
 
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SUBSCRIBER_LIMIT_REACHED);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->stringContainsString('You have reached the subscriber limit of your plan.');
@@ -120,7 +120,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
 
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_AUTHORIZATION);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->stringContainsString('Sending all of your emails has been paused');
@@ -134,7 +134,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
       'message' => 'error too big',
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->equals('error too big');
@@ -147,7 +147,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
       'message' => 'Api Error',
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->equals('Error while sending. Api Error');
@@ -160,7 +160,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
       'message' => '[{"index":0,"errors":{"subject":"subject is missing"}},{"index":1,"errors":{"subject":"subject is missing"}}]',
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_SOFT);
     $subscriberErrors = $error->getSubscriberErrors();
@@ -178,7 +178,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
       'message' => '[{"errors":{"subject":"subject is missing"}},{"errors":{"subject":"subject is missing"}}]',
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->equals('Error while sending. Invalid MSS response format.');
@@ -192,7 +192,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
       'error' => API::ERROR_MESSAGE_PENDING_APPROVAL,
     ];
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_PENDING_APPROVAL);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->stringContainsString('pending approval');
@@ -207,7 +207,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
     ];
 
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getRetryInterval())->equals(MailPoetMapper::TEMPORARY_UNAVAILABLE_RETRY_INTERVAL);
     verify($error->getOperation())->equals(MailerError::OPERATION_SEND);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
@@ -249,7 +249,7 @@ class MailPoetMapperTest extends \MailPoetUnitTest {
       $wpFunctions
     );
     $error = $this->mapper->getErrorForResult($apiResult, $this->subscribers);
-    expect($error)->isInstanceOf(MailerError::class);
+    verify($error)->instanceOf(MailerError::class);
     verify($error->getOperation())->equals(MailerError::OPERATION_EMAIL_LIMIT_REACHED);
     verify($error->getLevel())->equals(MailerError::LEVEL_HARD);
     verify($error->getMessage())->stringContainsString('You have sent more emails this month than your MailPoet plan includes (1000),');
diff --git a/mailpoet/tests/unit/Subscription/Captcha/Validator/BuiltInCaptchaValidatorTest.php b/mailpoet/tests/unit/Subscription/Captcha/Validator/BuiltInCaptchaValidatorTest.php
index 8acb06b032..f41d2f1c18 100644
--- a/mailpoet/tests/unit/Subscription/Captcha/Validator/BuiltInCaptchaValidatorTest.php
+++ b/mailpoet/tests/unit/Subscription/Captcha/Validator/BuiltInCaptchaValidatorTest.php
@@ -239,7 +239,7 @@ class BuiltInCaptchaValidatorTest extends \MailPoetUnitTest {
       verify($error->getMessage())->equals('Please regenerate the CAPTCHA.');
       verify($error->getMeta()['redirect_url'])->equals($newUrl);
     }
-    expect($error)->isInstanceOf(ValidationError::class);
+    verify($error)->instanceOf(ValidationError::class);
   }
 
   public function testCaptchaMissmatch() {
@@ -276,7 +276,7 @@ class BuiltInCaptchaValidatorTest extends \MailPoetUnitTest {
       verify($error->getMessage())->equals('The characters entered do not match with the previous CAPTCHA.');
       verify($error->getMeta()['refresh_captcha'])->true();
     }
-    expect($error)->isInstanceOf(ValidationError::class);
+    verify($error)->instanceOf(ValidationError::class);
   }
 
   public function testNoCaptchaIsSend() {
@@ -319,6 +319,6 @@ class BuiltInCaptchaValidatorTest extends \MailPoetUnitTest {
       verify($error->getMessage())->equals('Please fill in the CAPTCHA.');
       verify($error->getMeta()['redirect_url'])->equals($newUrl);
     }
-    expect($error)->isInstanceOf(ValidationError::class);
+    verify($error)->instanceOf(ValidationError::class);
   }
 }
diff --git a/mailpoet/tests/unit/Subscription/Captcha/Validator/RecaptchaValidatorTest.php b/mailpoet/tests/unit/Subscription/Captcha/Validator/RecaptchaValidatorTest.php
index 066f075fc8..8dc2434eaa 100644
--- a/mailpoet/tests/unit/Subscription/Captcha/Validator/RecaptchaValidatorTest.php
+++ b/mailpoet/tests/unit/Subscription/Captcha/Validator/RecaptchaValidatorTest.php
@@ -142,7 +142,7 @@ class RecaptchaValidatorTest extends \MailPoetUnitTest {
     } catch (ValidationError $error) {
       verify($error->getMessage())->equals('Error while validating the CAPTCHA.');
     }
-    expect($error)->isInstanceOf(ValidationError::class);
+    verify($error)->instanceOf(ValidationError::class);
   }
 
   public function testConnectionError() {
@@ -186,6 +186,6 @@ class RecaptchaValidatorTest extends \MailPoetUnitTest {
     } catch (ValidationError $error) {
       verify($error->getMessage())->equals('Error while validating the CAPTCHA.');
     }
-    expect($error)->isInstanceOf(ValidationError::class);
+    verify($error)->instanceOf(ValidationError::class);
   }
 }