ReturnUrlTest.php

Go to the documentation of this file.

<?php
namespace Magento\Paypal\Test\Unit\Controller\Payflow;

use Magento\Framework\Event\ManagerInterface;
use Magento\Sales\Api\PaymentFailuresInterface;
use Magento\Checkout\Block\Onepage\Success;
use Magento\Checkout\Model\Session;
use Magento\Framework\App\Action\Context;
use Magento\Framework\App\Http;
use Magento\Framework\App\ViewInterface;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Magento\Framework\View\LayoutInterface;
use Magento\Paypal\Controller\Payflow\ReturnUrl;
use Magento\Paypal\Controller\Payflowadvanced\ReturnUrl as PayflowadvancedReturnUrl;
use Magento\Paypal\Helper\Checkout;
use Magento\Paypal\Model\Config;
use Magento\Sales\Model\Order;
use Magento\Sales\Model\Order\Payment;
use Magento\Sales\Model\OrderFactory;
use PHPUnit_Framework_MockObject_MockObject as MockObject;

class ReturnUrlTest extends \PHPUnit\Framework\TestCase
{
    const LAST_REAL_ORDER_ID = '000000001';

    private $returnUrl;

    private $context;

    private $view;

    private $request;

    private $checkoutSession;

    private $orderFactory;

    private $checkoutHelper;

    private $block;

    private $layout;

    private $order;

    private $payment;

    private $objectManager;

    private $paymentFailures;

    private $eventManagerMock;

    protected function setUp()
    {
        $this->objectManager = new ObjectManager($this);

        $this->context = $this->getMockBuilder(Context::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->view = $this->getMockBuilder(ViewInterface::class)
            ->getMock();

        $this->request = $this->getMockBuilder(Http::class)
            ->disableOriginalConstructor()
            ->setMethods(['getParam'])
            ->getMock();

        $this->layout = $this->getMockBuilder(LayoutInterface::class)
            ->getMock();

        $this->block = $this->getMockBuilder(Success::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->orderFactory = $this->getMockBuilder(OrderFactory::class)
            ->disableOriginalConstructor()
            ->setMethods(['create'])
            ->getMock();

        $this->checkoutHelper = $this->getMockBuilder(Checkout::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->order = $this->getMockBuilder(Order::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->payment = $this->getMockBuilder(Payment::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->checkoutSession = $this->getMockBuilder(Session::class)
            ->disableOriginalConstructor()
            ->setMethods(['getLastRealOrderId', 'getLastRealOrder', 'restoreQuote'])
            ->getMock();

        $this->quote = $this->getMockBuilder(CartInterface::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->paymentFailures = $this->getMockBuilder(PaymentFailuresInterface::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->eventManagerMock = $this->getMockBuilder(ManagerInterface::class)
            ->disableOriginalConstructor()
            ->getMock();

        $this->context->method('getView')
            ->willReturn($this->view);
        $this->context->method('getRequest')
            ->willReturn($this->request);
        $this->context->method('getEventManager')
            ->willReturn($this->eventManagerMock);

        $this->returnUrl = $this->objectManager->getObject(
            ReturnUrl::class,
            [
                'context' => $this->context,
                'checkoutSession' => $this->checkoutSession,
                'orderFactory' => $this->orderFactory,
                'checkoutHelper' => $this->checkoutHelper,
                'paymentFailures' => $this->paymentFailures,
            ]
        );
    }

    public function testExecuteAllowedOrderState($state)
    {
        $this->withLayout();
        $this->withOrder(self::LAST_REAL_ORDER_ID, $state);

        $this->checkoutSession->method('getLastRealOrderId')
            ->willReturn(self::LAST_REAL_ORDER_ID);

        $this->block->method('setData')
            ->with('goto_success_page', true)
            ->willReturnSelf();

        $this->eventManagerMock->expects($this->once())
            ->method('dispatch')
            ->with('paypal_checkout_success', $this->arrayHasKey('order'));

        $result = $this->returnUrl->execute();
        $this->assertNull($result);
    }

    public function allowedOrderStateDataProvider()
    {
        return [
            [Order::STATE_PROCESSING],
            [Order::STATE_COMPLETE],
            [Order::STATE_PAYMENT_REVIEW],
        ];
    }

    public function testExecuteNotAllowedOrderState($state, $restoreQuote, $expectedGotoSection)
    {
        $errMessage = 'Transaction has been canceled.';
        $this->withLayout();
        $this->withOrder(self::LAST_REAL_ORDER_ID, $state);
        $this->withCheckoutSession(self::LAST_REAL_ORDER_ID, $restoreQuote);

        $this->request->method('getParam')
            ->with('RESPMSG')
            ->willReturn($errMessage);

        $this->payment->method('getMethod')
            ->willReturn(Config::METHOD_PAYFLOWLINK);

        $this->checkoutHelper->method('cancelCurrentOrder')
            ->with(self::equalTo($errMessage));

        $this->withBlockContent($expectedGotoSection, 'Your payment has been declined. Please try again.');

        $this->returnUrl->execute();
    }

    public function notAllowedOrderStateDataProvider()
    {
        return [
            [Order::STATE_NEW, false, ''],
            [Order::STATE_NEW, true, 'paymentMethod'],
            [Order::STATE_PENDING_PAYMENT, false, ''],
            [Order::STATE_PENDING_PAYMENT, true, 'paymentMethod'],
            [Order::STATE_CLOSED, false, ''],
            [Order::STATE_CLOSED, true, 'paymentMethod'],
            [Order::STATE_CANCELED, false, ''],
            [Order::STATE_CANCELED, true, 'paymentMethod'],
            [Order::STATE_HOLDED, false, ''],
            [Order::STATE_HOLDED, true, 'paymentMethod'],
        ];
    }

    public function testCheckRejectByPaymentMethod()
    {
        $this->withLayout();
        $this->withOrder(self::LAST_REAL_ORDER_ID, Order::STATE_NEW);

        $this->checkoutSession->method('getLastRealOrderId')
            ->willReturn(self::LAST_REAL_ORDER_ID);

        $this->withBlockContent(false, 'Requested payment method does not match with order.');

        $this->payment->expects(self::once())
            ->method('getMethod')
            ->willReturn('something_else');

        $this->returnUrl->execute();
    }

    public function testCheckXSSEscaped($errorMsg, $errorMsgEscaped)
    {
        $this->withLayout();
        $this->withOrder(self::LAST_REAL_ORDER_ID, Order::STATE_NEW);
        $this->withCheckoutSession(self::LAST_REAL_ORDER_ID, true);

        $this->request->method('getParam')
            ->with('RESPMSG')
            ->willReturn($errorMsg);

        $this->checkoutHelper->method('cancelCurrentOrder')
            ->with(self::equalTo($errorMsgEscaped));

        $this->withBlockContent('paymentMethod', 'Your payment has been declined. Please try again.');

        $this->payment->method('getMethod')
            ->willReturn(Config::METHOD_PAYFLOWLINK);

        $this->returnUrl->execute();
    }

    public function checkXSSEscapedDataProvider()
    {
        return [
            ['simple', 'simple'],
            ['<script>alert(1)</script>', 'alert(1)'],
            ['<div style="background-image:url(javascript:alert(1))">', '']
        ];
    }

    public function testCheckAdvancedAcceptingByPaymentMethod()
    {
        $this->withLayout();
        $this->withOrder(self::LAST_REAL_ORDER_ID, Order::STATE_NEW);
        $this->withCheckoutSession(self::LAST_REAL_ORDER_ID, true);

        $this->request->method('getParam')
            ->with('RESPMSG')
            ->willReturn('message');

        $this->withBlockContent('paymentMethod', 'Your payment has been declined. Please try again.');

        $this->payment->method('getMethod')
            ->willReturn(Config::METHOD_PAYFLOWADVANCED);

        $returnUrl = $this->objectManager->getObject(PayflowadvancedReturnUrl::class, [
            'context' => $this->context,
            'checkoutSession' => $this->checkoutSession,
            'orderFactory' => $this->orderFactory,
            'checkoutHelper' => $this->checkoutHelper,
            'paymentFailures' => $this->paymentFailures,
        ]);

        $returnUrl->execute();
    }

    private function withOrder($incrementId, $state)
    {
        $this->orderFactory->method('create')
            ->willReturn($this->order);

        $this->order->method('loadByIncrementId')
            ->with($incrementId)
            ->willReturnSelf();

        $this->order->method('getIncrementId')
            ->willReturn($incrementId);

        $this->order->method('getState')
            ->willReturn($state);

        $this->order->method('getPayment')
            ->willReturn($this->payment);
    }

    private function withLayout()
    {
        $this->view->method('getLayout')
            ->willReturn($this->layout);

        $this->layout->method('getBlock')
            ->willReturn($this->block);
    }

    private function withCheckoutSession($orderId, $restoreQuote)
    {
        $this->checkoutSession->method('getLastRealOrderId')
            ->willReturn($orderId);

        $this->checkoutSession->method('getLastRealOrder')
            ->willReturn($this->order);

        $this->checkoutSession->method('restoreQuote')
            ->willReturn($restoreQuote);
    }

    private function withBlockContent($gotoSection, $errMsg)
    {
        $this->block->expects(self::at(0))
            ->method('setData')
            ->with('goto_section', self::equalTo($gotoSection))
            ->willReturnSelf();

        $this->block->expects(self::at(1))
            ->method('setData')
            ->with('error_msg', self::equalTo(__($errMsg)))
            ->willReturnSelf();
    }
}