Cavemanon/piratepoet
7
Fork 0
Code Pull Requests Actions Releases 16 Activity

Replace expect()->isInstanceOf() with verify()->instanceOf()

Browse Source 
codeception/verify 2.1 removed support for expect()->isInstanceOf() so we need
to replace it with verify()->instanceOf().

[MAILPOET-5664]
This commit is contained in:
Rodrigo Primo
2023-10-18 16:08:25 -03:00
committed by David Remer
parent 5bc5b5ebd2
commit 1865fc8930
39 changed files with 146 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
mailpoet/tests/integration/API/APITest.php
View File

@ -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() {

12
mailpoet/tests/integration/API/JSON/v1/DynamicSegmentsTest.php
View File

@ -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.');
}

8
mailpoet/tests/integration/API/JSON/v1/SettingsTest.php
View File

@ -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');

6
mailpoet/tests/integration/API/JSON/v1/SubscribersTest.php
View File

@ -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);

4
mailpoet/tests/integration/Cron/Workers/InactiveSubscribersTest.php
View File

@ -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());
}

10
mailpoet/tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php
View File

@ -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');

2
mailpoet/tests/integration/Cron/Workers/SubscribersLifetimeEmailCountTest.php
View File

@ -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());
}

4
mailpoet/tests/integration/Cron/Workers/SubscribersStatsReportTest.php
View File

@ -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());

12
mailpoet/tests/integration/Doctrine/ConfigurationFactoryTest.php
View File

@ -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'));

14
mailpoet/tests/integration/Doctrine/ConnectionFactoryTest.php
View File

@ -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');
}

4
mailpoet/tests/integration/Doctrine/Types/JsonTypesTest.php
View File

@ -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() {

2
mailpoet/tests/integration/Form/FormsRepositoryTest.php
View File

@ -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();
}

4
mailpoet/tests/integration/Mailer/Methods/AmazonSESTest.php
View File

@ -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.');
}

14
mailpoet/tests/integration/Mailer/Methods/MailPoetAPITest.php
View File

@ -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.');
}

4
mailpoet/tests/integration/Mailer/Methods/PHPMailTest.php
View File

@ -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.');
}

2
mailpoet/tests/integration/Mailer/Methods/SMTPTest.php
View File

@ -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.');
}

2
mailpoet/tests/integration/Mailer/Methods/SendGridTest.php
View File

@ -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.');
}

4
mailpoet/tests/integration/Migrator/TestMigrations/App/Migration_20221023_080348.php
View File

@ -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);
}
}

2
mailpoet/tests/integration/Migrator/TestMigrations/Db/Migration_20221024_080348.php
View File

@ -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);
}
}

2
mailpoet/tests/integration/Models/NewsletterTest.php
View File

@ -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);
}

4
mailpoet/tests/integration/Newsletter/NewsletterRepositoryTest.php
View File

@ -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();

6
mailpoet/tests/integration/Newsletter/Sending/ScheduledTasksRepositoryTest.php
View File

@ -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() {

48
mailpoet/tests/integration/Segments/DynamicSegments/FilterDataMapperTest.php
View File

@ -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([

12
mailpoet/tests/integration/Segments/SegmentsRepositoryTest.php
View File

@ -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();
}

4
mailpoet/tests/integration/Settings/SettingsChangeHandlerTest.php
View File

@ -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 {

2
mailpoet/tests/integration/Statistics/StatisticsFormsRepositoryTest.php
View File

@ -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 {

4
mailpoet/tests/integration/Subscribers/ConfirmationEmailCustomizerTest.php
View File

@ -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);

10
mailpoet/tests/integration/Subscribers/ImportExport/Import/ImportTest.php
View File

@ -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);
}
}

2
mailpoet/tests/integration/Subscribers/SubscriberActionsTest.php
View File

@ -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() {

8
mailpoet/tests/integration/Subscribers/SubscriberSubscribeControllerTest.php
View File

@ -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()]);

4
mailpoet/tests/integration/Tasks/SendingTest.php
View File

@ -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

2
mailpoet/tests/unit/API/JSON/ErrorHandlerTest.php
View File

@ -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']]);
}

14
mailpoet/tests/unit/API/JSON/PremiumTest.php
View File

@ -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.',

14
mailpoet/tests/unit/DI/ContainerWrapperTest.php
View File

@ -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);
}
}

2
mailpoet/tests/unit/Form/Templates/TemplatesRepositoryTest.php
View File

@ -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();

4
mailpoet/tests/unit/Logging/LoggerFactoryTest.php
View File

@ -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() {

28
mailpoet/tests/unit/Mailer/Methods/ErrorMappers/MailPoetMapperTest.php
View File

@ -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),');

6
mailpoet/tests/unit/Subscription/Captcha/Validator/BuiltInCaptchaValidatorTest.php
View File

@ -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);
}
}

4
mailpoet/tests/unit/Subscription/Captcha/Validator/RecaptchaValidatorTest.php
View File

@ -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);
}
}