389 lines
12 KiB
PHP
389 lines
12 KiB
PHP
<?php declare(strict_types = 1);
|
|
|
|
use Automattic\WooCommerce\Admin\API\Reports\Orders\Stats\DataStore;
|
|
use Codeception\Scenario;
|
|
use MailPoet\Automation\Engine\Data\Automation;
|
|
use MailPoet\Automation\Engine\Data\AutomationRun;
|
|
use MailPoet\Automation\Engine\Data\NextStep;
|
|
use MailPoet\Automation\Engine\Data\Step;
|
|
use MailPoet\Automation\Engine\Storage\AutomationRunStorage;
|
|
use MailPoet\Automation\Engine\Storage\AutomationStorage;
|
|
use MailPoet\Automation\Integrations\Core\Actions\DelayAction;
|
|
use MailPoet\DI\ContainerWrapper;
|
|
use MailPoet\Entities\DynamicSegmentFilterData;
|
|
use MailPoet\Entities\DynamicSegmentFilterEntity;
|
|
use MailPoet\Entities\SegmentEntity;
|
|
use MailPoet\Entities\SubscriberEntity;
|
|
use MailPoet\InvalidStateException;
|
|
use MailPoet\Segments\DynamicSegments\Filters\Filter;
|
|
use MailPoet\Util\Security;
|
|
use MailPoet\WooCommerce\Helper;
|
|
use MailPoetVendor\Carbon\Carbon;
|
|
use MailPoetVendor\Doctrine\DBAL\Driver\Statement;
|
|
use MailPoetVendor\Doctrine\DBAL\Query\QueryBuilder;
|
|
use MailPoetVendor\Doctrine\ORM\EntityManager;
|
|
|
|
require_once(ABSPATH . 'wp-admin/includes/user.php');
|
|
require_once(ABSPATH . 'wp-admin/includes/ms.php');
|
|
|
|
/**
|
|
* Inherited Methods
|
|
* @method void wantToTest($text)
|
|
* @method void wantTo($text)
|
|
* @method void execute($callable)
|
|
* @method void expectTo($prediction)
|
|
* @method void expect($prediction)
|
|
* @method void amGoingTo($argumentation)
|
|
* @method void am($role)
|
|
* @method void lookForwardTo($achieveValue)
|
|
* @method void comment($description)
|
|
* @method \Codeception\Lib\Friend haveFriend($name, $actorClass = null)
|
|
*
|
|
* @SuppressWarnings(PHPMD)
|
|
*/
|
|
// phpcs:ignore PSR1.Classes.ClassDeclaration
|
|
class IntegrationTester extends \Codeception\Actor {
|
|
use _generated\IntegrationTesterActions;
|
|
|
|
/** @var EntityManager */
|
|
private $entityManager;
|
|
|
|
private $wpTermIds = [];
|
|
|
|
private $wooProductIds = [];
|
|
|
|
private $wooOrderIds = [];
|
|
|
|
private $wooCouponIds = [];
|
|
|
|
private $createdUsers = [];
|
|
|
|
private $createdCommentIds = [];
|
|
|
|
public function __construct(
|
|
Scenario $scenario
|
|
) {
|
|
parent::__construct($scenario);
|
|
$this->entityManager = ContainerWrapper::getInstance()->get(EntityManager::class);
|
|
}
|
|
|
|
public function createWordPressUser(string $email, string $role) {
|
|
$userId = wp_insert_user([
|
|
'user_login' => explode('@', $email)[0],
|
|
'user_email' => $email,
|
|
'role' => $role,
|
|
'user_pass' => '12123154',
|
|
]);
|
|
|
|
if ($userId instanceof WP_Error) {
|
|
throw new Exception(sprintf("Unable to create WordPress user with email $email: %s", $userId->get_error_message()));
|
|
}
|
|
|
|
$this->createdUsers[] = $email;
|
|
|
|
return $userId;
|
|
}
|
|
|
|
public function createWordPressTerm(string $term, string $taxonomy, array $args = []): int {
|
|
$term = wp_insert_term($term, $taxonomy, $args);
|
|
if ($term instanceof WP_Error) {
|
|
throw new InvalidStateException('Failed to create term');
|
|
}
|
|
|
|
$this->wpTermIds[$taxonomy] = $this->wpTermIds[$taxonomy] ?? [];
|
|
$this->wpTermIds[$taxonomy][] = $term['term_id'];
|
|
return $term['term_id'];
|
|
}
|
|
|
|
public function createCustomer(string $email, string $role = 'customer'): int {
|
|
return $this->createWordPressUser($email, $role);
|
|
}
|
|
|
|
public function deleteCreatedUsers() {
|
|
foreach ($this->createdUsers as $createdUserEmail) {
|
|
$this->deleteWordPressUser($createdUserEmail);
|
|
}
|
|
$this->createdUsers = [];
|
|
}
|
|
|
|
public function deleteWordPressUser(string $email) {
|
|
$user = get_user_by('email', $email);
|
|
if (!$user) {
|
|
return;
|
|
}
|
|
if (is_multisite()) {
|
|
wpmu_delete_user($user->ID);
|
|
} else {
|
|
wp_delete_user($user->ID);
|
|
}
|
|
}
|
|
|
|
public function createWooCommerceProduct(array $data): WC_Product {
|
|
$product = new WC_Product_Simple();
|
|
|
|
if (isset($data['name'])) {
|
|
$product->set_name($data['name']);
|
|
}
|
|
|
|
if (isset($data['category_ids'])) {
|
|
$product->set_category_ids($data['category_ids']);
|
|
}
|
|
|
|
if (isset($data['tag_ids'])) {
|
|
$product->set_tag_ids($data['tag_ids']);
|
|
}
|
|
|
|
$product->save();
|
|
$this->wooProductIds[] = $product->get_id();
|
|
return $product;
|
|
}
|
|
|
|
/**
|
|
* @param array $data - includes default args for wc_create_order plus some extras.
|
|
* The defaults are currently:
|
|
* 'status' => null,
|
|
* 'customer_id' => null,
|
|
* 'customer_note' => null,
|
|
* 'parent' => null,
|
|
* 'created_via' => null,
|
|
* 'cart_hash' => null,
|
|
* @return WC_Order
|
|
*/
|
|
public function createWooCommerceOrder(array $data = []): \WC_Order {
|
|
$helper = ContainerWrapper::getInstance()->get(Helper::class);
|
|
$order = $helper->wcCreateOrder($data);
|
|
|
|
$order->set_billing_email($data['billing_email'] ?? md5($this->uniqueId()) . '@example.com');
|
|
|
|
if (isset($data['date_created'])) {
|
|
$order->set_date_created($data['date_created']);
|
|
}
|
|
|
|
if (isset($data['billing_postcode'])) {
|
|
$order->set_billing_postcode($data['billing_postcode']);
|
|
}
|
|
|
|
if (isset($data['billing_city'])) {
|
|
$order->set_billing_city($data['billing_city']);
|
|
}
|
|
|
|
if (isset($data['total'])) {
|
|
$order->set_total($data['total']);
|
|
}
|
|
|
|
$order->save();
|
|
|
|
$orderId = $order->get_id();
|
|
$this->wooOrderIds[] = $orderId;
|
|
$this->updateWooOrderStats($orderId);
|
|
|
|
return $order;
|
|
}
|
|
|
|
public function createWooProductReview(int $customerId, string $customerEmail, int $productId, int $rating, Carbon $date = null): int {
|
|
if ($date === null) {
|
|
$date = Carbon::now()->subDay();
|
|
}
|
|
$commentId = wp_insert_comment([
|
|
'comment_type' => 'review',
|
|
'user_id' => $customerId,
|
|
'comment_author_email' => $customerEmail,
|
|
'comment_post_ID' => $productId,
|
|
'comment_parent' => 0,
|
|
'comment_date' => $date->toDateTimeString(),
|
|
'comment_approved' => 1,
|
|
'comment_content' => "This is a $rating star review",
|
|
]);
|
|
if (!is_int($commentId)) {
|
|
throw new \Exception('Failed to insert review comment');
|
|
}
|
|
add_comment_meta($commentId, 'rating', $rating, true);
|
|
$this->createdCommentIds[] = $commentId;
|
|
return $commentId;
|
|
}
|
|
|
|
public function createWooCommerceCoupon(array $data): void {
|
|
$coupon = new WC_Coupon();
|
|
|
|
if (isset($data['code'])) {
|
|
$coupon->set_code($data['code']);
|
|
}
|
|
|
|
$coupon->save();
|
|
$this->wooCouponIds[] = $coupon->get_id();
|
|
}
|
|
|
|
public function updateWooOrderStats(int $orderId): void {
|
|
if (!class_exists('Automattic\WooCommerce\Admin\API\Reports\Orders\Stats\DataStore')) {
|
|
return;
|
|
}
|
|
DataStore::sync_order($orderId);
|
|
}
|
|
|
|
public function deleteWordPressTerms(): void {
|
|
foreach ($this->wpTermIds as $taxonomy => $termIds) {
|
|
foreach ($termIds as $termId) {
|
|
wp_delete_term($termId, $taxonomy);
|
|
}
|
|
}
|
|
$this->wpTermIds = [];
|
|
}
|
|
|
|
public function deleteTestWooOrder(int $wooOrderId) {
|
|
$helper = ContainerWrapper::getInstance()->get(Helper::class);
|
|
$order = $helper->wcGetOrder($wooOrderId);
|
|
if ($order instanceof \WC_Order) {
|
|
$order->delete(true);
|
|
}
|
|
}
|
|
|
|
public function deleteTestWooProducts(): void {
|
|
$helper = ContainerWrapper::getInstance()->get(Helper::class);
|
|
foreach ($this->wooProductIds as $wooProductId) {
|
|
$product = $helper->wcGetProduct($wooProductId);
|
|
if ($product instanceof WC_Product) {
|
|
$product->delete(true);
|
|
}
|
|
}
|
|
$this->wooProductIds = [];
|
|
}
|
|
|
|
public function deleteTestWooOrders() {
|
|
$helper = ContainerWrapper::getInstance()->get(Helper::class);
|
|
foreach ($this->wooOrderIds as $wooOrderId) {
|
|
$order = $helper->wcGetOrder($wooOrderId);
|
|
if ($order instanceof \WC_Order) {
|
|
$order->delete(true);
|
|
}
|
|
}
|
|
$this->wooOrderIds = [];
|
|
}
|
|
|
|
public function deleteTestWooCoupons(): void {
|
|
foreach ($this->wooCouponIds as $couponId) {
|
|
$coupon = new WC_Coupon($couponId);
|
|
if ($coupon->get_id() > 0) {
|
|
$coupon->delete(true);
|
|
}
|
|
}
|
|
$this->wooCouponIds = [];
|
|
}
|
|
|
|
public function uniqueId($length = 10): string {
|
|
return Security::generateRandomString($length);
|
|
}
|
|
|
|
/**
|
|
* Compares two DateTimeInterface objects by comparing timestamp values.
|
|
* $delta parameter specifies tolerated difference
|
|
*/
|
|
public function assertEqualDateTimes(?DateTimeInterface $date1, ?DateTimeInterface $date2, int $delta = 0) {
|
|
if (!$date1 instanceof DateTimeInterface) {
|
|
throw new \Exception('$date1 is not DateTimeInterface');
|
|
}
|
|
if (!$date2 instanceof DateTimeInterface) {
|
|
throw new \Exception('$date2 is not DateTimeInterface');
|
|
}
|
|
expect($date1->getTimestamp())->equals($date2->getTimestamp(), $delta);
|
|
}
|
|
|
|
public function createAutomation(string $name, Step ...$steps): ?Automation {
|
|
$automationStorage = ContainerWrapper::getInstance()->get(AutomationStorage::class);
|
|
|
|
if (!$steps) {
|
|
$steps[] = new Step('trigger', Step::TYPE_TRIGGER, \MailPoet\Automation\Integrations\MailPoet\Triggers\SomeoneSubscribesTrigger::KEY, [], []);
|
|
}
|
|
//If we only have a trigger, add a delay step to make the automation valid.
|
|
if (count($steps) === 1) {
|
|
$delay = ContainerWrapper::getInstance()->get(DelayAction::class);
|
|
$delayStep = new Step('delay', Step::TYPE_ACTION, $delay->getKey(), [], []);
|
|
$steps[0]->setNextSteps([new NextStep($delayStep->getId())]);
|
|
$steps[] = $delayStep;
|
|
}
|
|
$steps = array_merge(
|
|
[
|
|
'root' => new Step('root', Step::TYPE_ROOT, 'root', [], [new NextStep($steps[0]->getId())]),
|
|
],
|
|
$steps
|
|
);
|
|
|
|
$stepsWithIds = [];
|
|
foreach ($steps as $step) {
|
|
$stepsWithIds[$step->getId()] = $step;
|
|
}
|
|
$automation = new Automation($name, $stepsWithIds, wp_get_current_user());
|
|
$automation->setStatus(Automation::STATUS_ACTIVE);
|
|
return $automationStorage->getAutomation($automationStorage->createAutomation($automation));
|
|
}
|
|
|
|
public function createAutomationRun(Automation $automation, $subjects = []): ?AutomationRun {
|
|
$trigger = array_filter($automation->getSteps(), function(Step $step): bool { return $step->getType() === Step::TYPE_TRIGGER;
|
|
|
|
});
|
|
$triggerKeys = array_map(function(Step $step): string { return $step->getKey();
|
|
|
|
}, $trigger);
|
|
$triggerKey = count($triggerKeys) > 0 ? current($triggerKeys) : '';
|
|
|
|
$automationRun = new AutomationRun(
|
|
$automation->getId(),
|
|
$automation->getVersionId(),
|
|
$triggerKey,
|
|
$subjects
|
|
);
|
|
$automationRunStorage = ContainerWrapper::getInstance()->get(AutomationRunStorage::class);
|
|
return $automationRunStorage->getAutomationRun($automationRunStorage->createAutomationRun($automationRun));
|
|
}
|
|
|
|
public function getSubscriberEmailsMatchingDynamicFilter(DynamicSegmentFilterData $data, Filter $filter): array {
|
|
$segment = new SegmentEntity('temporary segment', SegmentEntity::TYPE_DYNAMIC, 'description');
|
|
$this->entityManager->persist($segment);
|
|
$filterEntity = new DynamicSegmentFilterEntity($segment, $data);
|
|
$this->entityManager->persist($filterEntity);
|
|
$segment->addDynamicFilter($filterEntity);
|
|
$queryBuilder = $filter->apply($this->getSubscribersQueryBuilder(), $filterEntity);
|
|
return $this->getSubscriberEmailsFromQueryBuilder($queryBuilder);
|
|
}
|
|
|
|
/**
|
|
* @param QueryBuilder $queryBuilder
|
|
* @return string[] - array of subscriber emails
|
|
*/
|
|
public function getSubscriberEmailsFromQueryBuilder(QueryBuilder $queryBuilder): array {
|
|
$statement = $queryBuilder->execute();
|
|
$results = $statement instanceof Statement ? $statement->fetchAllAssociative() : [];
|
|
return array_map(function($row) {
|
|
$subscriber = $this->entityManager->find(SubscriberEntity::class, $row['inner_subscriber_id']);
|
|
if (!$subscriber instanceof SubscriberEntity) {
|
|
throw new \Exception('this is for PhpStan');
|
|
}
|
|
return $subscriber->getEmail();
|
|
}, $results);
|
|
}
|
|
|
|
public function getSubscribersQueryBuilder(): QueryBuilder {
|
|
$subscribersTable = $this->entityManager->getClassMetadata(SubscriberEntity::class)->getTableName();
|
|
return $this->entityManager
|
|
->getConnection()
|
|
->createQueryBuilder()
|
|
->select("DISTINCT $subscribersTable.id as inner_subscriber_id")
|
|
->from($subscribersTable);
|
|
}
|
|
|
|
public function cleanup() {
|
|
$this->deleteWordPressTerms();
|
|
$this->deleteCreatedUsers();
|
|
$this->deleteCreatedComments();
|
|
$this->deleteTestWooProducts();
|
|
$this->deleteTestWooOrders();
|
|
$this->deleteTestWooCoupons();
|
|
}
|
|
|
|
private function deleteCreatedComments() {
|
|
foreach ($this->createdCommentIds as $commentId) {
|
|
wp_delete_comment($commentId, true);
|
|
}
|
|
$this->createdCommentIds = [];
|
|
}
|
|
}
|