/**
  * @dataProvider canVoidDataProvider
  * @param bool $canVoid
  */
 public function testCanVoid($canVoid)
 {
     $this->_orderMock->expects($this->once())->method('getPayment')->will($this->returnValue($this->_paymentMock));
     $this->_paymentMock->expects($this->once())->method('canVoid', '__wakeup')->with($this->equalTo($this->_model))->will($this->returnValue($canVoid));
     $this->_model->setState(\Magento\Sales\Model\Order\Invoice::STATE_PAID);
     $this->assertEquals($canVoid, $this->_model->canVoid());
 }

 /**
  * @dataProvider canVoidDataProvider
  * @param bool $canVoid
  */
 public function testCanVoid($canVoid)
 {
     $entityName = 'invoice';
     $this->orderMock->expects($this->once())->method('getPayment')->will($this->returnValue($this->_paymentMock));
     $this->orderMock->expects($this->once())->method('setHistoryEntityName')->with($entityName)->will($this->returnSelf());
     $this->_paymentMock->expects($this->once())->method('canVoid', '__wakeup')->will($this->returnValue($canVoid));
     $this->model->setState(\Magento\Sales\Model\Order\Invoice::STATE_PAID);
     $this->assertEquals($canVoid, $this->model->canVoid());
 }

 /**
  * @covers \Magento\BraintreeTwo\Gateway\Response\CaptureDetailsHandler::handle
  */
 public function testHandle()
 {
     $paymentData = $this->getPaymentDataObjectMock();
     $subject['payment'] = $paymentData;
     $this->payment->expects(static::once())->method('setIsTransactionClosed')->with(false);
     $response = ['object' => ['success' => true]];
     $this->subjectReader->expects(self::once())->method('readPayment')->with($subject)->willReturn($paymentData);
     $this->captureHandler->handle($subject, $response);
 }

 protected function setUp()
 {
     $this->payment = $this->getMockBuilder(Payment::class)->disableOriginalConstructor()->setMethods(['setCcTransId', 'setLastTransId', 'setAdditionalInformation'])->getMock();
     $this->subjectReader = $this->getMockBuilder(SubjectReader::class)->disableOriginalConstructor()->getMock();
     $this->payment->expects(static::once())->method('setCcTransId');
     $this->payment->expects(static::once())->method('setLastTransId');
     $this->payment->expects(static::any())->method('setAdditionalInformation');
     $this->paymentHandler = new PaymentDetailsHandler($this->subjectReader);
 }

 public function testBuild()
 {
     $additionalData = [DataAssignObserver::DEVICE_DATA => self::DEVICE_DATA];
     $expectedResult = [KountPaymentDataBuilder::DEVICE_DATA => self::DEVICE_DATA];
     $buildSubject = ['payment' => $this->paymentDO];
     $this->paymentMock->expects(static::exactly(count($additionalData)))->method('getAdditionalInformation')->willReturn($additionalData);
     $this->configMock->expects(static::once())->method('hasFraudProtection')->willReturn(true);
     $this->paymentDO->expects(static::once())->method('getPayment')->willReturn($this->paymentMock);
     $this->subjectReaderMock->expects(self::once())->method('readPayment')->with($buildSubject)->willReturn($this->paymentDO);
     static::assertEquals($expectedResult, $this->builder->build($buildSubject));
 }

 /**
  * @covers \Magento\BraintreeTwo\Gateway\Response\CloneDetailsHandler::handle
  */
 public function testHandle()
 {
     $paymentData = $this->getPaymentDataObjectMock();
     $transaction = $this->getBraintreeTransaction();
     $subject['payment'] = $paymentData;
     $this->payment->expects(static::once())->method('setTransactionId')->with(self::TRANSACTION_ID);
     $response = ['object' => $transaction];
     $this->subjectReader->expects(self::once())->method('readPayment')->with($subject)->willReturn($paymentData);
     $this->subjectReader->expects(self::once())->method('readTransaction')->with($response)->willReturn($transaction);
     $this->cloneHandler->handle($subject, $response);
 }

 public function testBuild()
 {
     $additionalData = [[DataAssignObserver::PAYMENT_METHOD_NONCE, self::PAYMENT_METHOD_NONCE]];
     $expectedResult = [PaymentDataBuilder::AMOUNT => 10.0, PaymentDataBuilder::PAYMENT_METHOD_NONCE => self::PAYMENT_METHOD_NONCE, PaymentDataBuilder::MERCHANT_ACCOUNT_ID => self::MERCHANT_ACCOUNT_ID];
     $buildSubject = ['payment' => $this->paymentDO, 'amount' => 10.0];
     $this->paymentMock->expects(static::exactly(count($additionalData)))->method('getAdditionalInformation')->willReturnMap($additionalData);
     $this->configMock->expects(static::once())->method('getValue')->with(Config::KEY_MERCHANT_ACCOUNT_ID)->willReturn(self::MERCHANT_ACCOUNT_ID);
     $this->paymentDO->expects(static::once())->method('getPayment')->willReturn($this->paymentMock);
     $this->subjectReaderMock->expects(self::once())->method('readPayment')->with($buildSubject)->willReturn($this->paymentDO);
     $this->subjectReaderMock->expects(self::once())->method('readAmount')->with($buildSubject)->willReturn(10.0);
     static::assertEquals($expectedResult, $this->builder->build($buildSubject));
 }

 /**
  * @covers \Magento\BraintreeTwo\Gateway\Response\ThreeDSecureDetailsHandler::handle
  */
 public function testHandle()
 {
     $paymentData = $this->getPaymentDataObjectMock();
     $transaction = $this->getBraintreeTransaction();
     $subject = ['payment' => $paymentData];
     $response = ['object' => $transaction];
     $this->subjectReaderMock->expects(self::once())->method('readPayment')->with($subject)->willReturn($paymentData);
     $this->subjectReaderMock->expects(self::once())->method('readTransaction')->with($response)->willReturn($transaction);
     $this->payment->expects(static::at(1))->method('setAdditionalInformation')->with('liabilityShifted', 'Yes');
     $this->payment->expects(static::at(2))->method('setAdditionalInformation')->with('liabilityShiftPossible', 'Yes');
     $this->handler->handle($subject, $response);
 }

 /**
  * @covers \Magento\BraintreeTwo\Gateway\Response\PayPalDetailsHandler::handle
  */
 public function testHandle()
 {
     $paymentData = $this->getPaymentDataObjectMock();
     $transaction = $this->getBraintreeTransaction();
     $subject = ['payment' => $paymentData];
     $response = ['object' => $transaction];
     $this->subjectReader->expects(self::once())->method('readPayment')->with($subject)->willReturn($paymentData);
     $this->subjectReader->expects(self::once())->method('readTransaction')->with($response)->willReturn($transaction);
     $this->subjectReader->expects(static::once())->method('readPayPal')->with($transaction)->willReturn($transaction->paypal);
     $this->payment->expects(static::exactly(2))->method('setAdditionalInformation');
     $this->payPalHandler->handle($subject, $response);
 }

 /**
  * @covers \Magento\Braintree\Gateway\Request\CaptureDataBuilder::build
  */
 public function testBuild()
 {
     $transactionId = 'b3b99d';
     $amount = 10.0;
     $expected = ['transaction_id' => $transactionId, 'amount' => $amount];
     $buildSubject = ['payment' => $this->paymentDO, 'amount' => $amount];
     $this->payment->expects(static::once())->method('getCcTransId')->willReturn($transactionId);
     $this->paymentDO->expects(static::once())->method('getPayment')->willReturn($this->payment);
     $this->subjectReaderMock->expects(self::once())->method('readPayment')->with($buildSubject)->willReturn($this->paymentDO);
     $this->subjectReaderMock->expects(self::once())->method('readAmount')->with($buildSubject)->willReturn($amount);
     static::assertEquals($expected, $this->builder->build($buildSubject));
 }

 public function aroundIsCaptureFinal(\Magento\Sales\Model\Order\Payment $subject, \Closure $proceed, $amountToCapture)
 {
     $result = $proceed($amountToCapture);
     if (!$result) {
         $order = $subject->getOrder();
         $invoices = $order->getInvoiceCollection();
         $invoice = $invoices->getFirstItem();
         $grandTotalBase = $invoice->getBaseGrandTotal();
         /* validate with partial amount if exists */
         $result = $grandTotalBase == $amountToCapture;
     }
     return $result;
 }

 /**
  * \Magento\BraintreeTwo\Gateway\Request\VaultCaptureDataBuilder::build
  */
 public function testBuild()
 {
     $amount = 30.0;
     $token = '5tfm4c';
     $buildSubject = ['payment' => $this->paymentDO, 'amount' => $amount];
     $expected = ['amount' => $amount, 'paymentMethodToken' => $token];
     $this->subjectReader->expects(self::once())->method('readPayment')->with($buildSubject)->willReturn($this->paymentDO);
     $this->subjectReader->expects(self::once())->method('readAmount')->with($buildSubject)->willReturn($amount);
     $paymentExtension = $this->getMockBuilder(OrderPaymentExtension::class)->setMethods(['getVaultPaymentToken'])->disableOriginalConstructor()->getMock();
     $paymentToken = $this->getMockBuilder(PaymentToken::class)->disableOriginalConstructor()->getMock();
     $paymentExtension->expects(static::once())->method('getVaultPaymentToken')->willReturn($paymentToken);
     $this->payment->expects(static::once())->method('getExtensionAttributes')->willReturn($paymentExtension);
     $paymentToken->expects(static::once())->method('getGatewayToken')->willReturn($token);
     $result = $this->builder->build($buildSubject);
     static::assertEquals($expected, $result);
 }

 /**
  * @param $context
  */
 protected function initPayment($context)
 {
     $this->payment = (new \Magento\Framework\TestFramework\Unit\Helper\ObjectManager($this))->getObject('Magento\\Sales\\Model\\Order\\Payment', ['context' => $context, 'serviceOrderFactory' => $this->serviceOrderFactory, 'paymentData' => $this->helperMock, 'priceCurrency' => $this->priceCurrencyMock, 'transactionFactory' => $this->transactionFactory, 'transactionCollectionFactory' => $this->transactionCollectionFactory]);
     $this->payment->setMethod('any');
     $this->payment->setOrder($this->orderMock);
     $this->transactionId = 100;
 }

 /**
  * @covers \Magento\Sales\Model\Order\Payment::getShouldCloseParentTransaction()
  * @return void
  */
 public function testGetShouldCloseParentTransaction()
 {
     $this->payment->setShouldCloseParentTransaction(1);
     static::assertTrue($this->payment->getShouldCloseParentTransaction());
     $this->payment->setShouldCloseParentTransaction(0);
     static::assertFalse($this->payment->getShouldCloseParentTransaction());
 }

 /**
  * Magento will consider a transaction for voiding only if it is an authorization
  * Braintree allows voiding captures too
  *
  * Lookup an authorization transaction using parent transaction id, if set
  *
  * @param Payment $subject
  * @param callable $proceed
  *
  * @return \Magento\Sales\Model\Order\Payment\Transaction|false
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  */
 public function aroundGetAuthorizationTransaction(Payment $subject, \Closure $proceed)
 {
     if ($subject->getMethodInstance()->getCode() != PaymentMethod::METHOD_CODE) {
         return $proceed();
     }
     $invoice = $this->registry->registry('current_invoice');
     if ($invoice && $invoice->getId()) {
         $transactionId = $this->paymentHelper->clearTransactionId($invoice->getTransactionId());
         $collection = $this->salesTransactionCollectionFactory->create()->addFieldToFilter('txn_id', ['eq' => $transactionId]);
         if ($collection->getSize() < 1) {
             return $proceed();
         } else {
             return $collection->getFirstItem();
         }
     }
     return $proceed();
 }

 public function testExecuteUpdateAction()
 {
     $orderId = 30;
     $action = 'update';
     $this->requestMock->expects($this->at(0))->method('getParam')->with('order_id')->willReturn($orderId);
     $this->requestMock->expects($this->at(1))->method('getParam')->with('action')->willReturn($action);
     $this->resultRedirectFactoryMock->expects($this->once())->method('create')->willReturn($this->resultRedirectMock);
     $this->objectManagerMock->expects($this->once())->method('create')->with('Magento\\Sales\\Model\\Order')->willReturn($this->orderMock);
     $this->orderMock->expects($this->once())->method('load')->with($orderId)->willReturn($this->orderMock);
     $this->orderMock->expects($this->any())->method('getId')->willReturn($orderId);
     $this->orderMock->expects($this->once())->method('getPayment')->willReturn($this->paymentMock);
     $this->orderMock->expects($this->once())->method('save')->willReturnSelf();
     $this->messageManagerMock->expects($this->once())->method('addSuccess')->with('The payment update has been made.');
     $this->resultRedirectMock->expects($this->once())->method('setPath')->with('sales/*/')->willReturnSelf();
     $this->paymentMock->expects($this->once())->method('update');
     $result = $this->reviewPayment->execute();
     $this->assertEquals($this->resultRedirectMock, $result);
 }

 public function testExecuteUpdateAction()
 {
     $orderId = 30;
     $action = 'update';
     $this->requestMock->expects($this->at(0))->method('getParam')->with('order_id')->willReturn($orderId);
     $this->requestMock->expects($this->at(1))->method('getParam')->with('action')->willReturn($action);
     $this->resultRedirectFactoryMock->expects($this->once())->method('create')->willReturn($this->resultRedirectMock);
     $this->orderRepositoryMock->expects($this->once())->method('get')->with($orderId)->willReturn($this->orderMock);
     $this->orderMock->expects($this->any())->method('getEntityId')->willReturn($orderId);
     $this->orderMock->expects($this->any())->method('getPayment')->willReturn($this->paymentMock);
     $this->orderRepositoryMock->expects($this->once())->method('save')->with($this->orderMock)->willReturnSelf();
     $this->paymentMock->expects($this->once())->method('update');
     $this->paymentMock->expects($this->any())->method('getIsTransactionApproved')->willReturn(true);
     $this->messageManagerMock->expects($this->once())->method('addSuccess');
     $this->resultRedirectMock->expects($this->once())->method('setPath')->with('sales/order/view')->willReturnSelf();
     $result = $this->reviewPayment->execute();
     $this->assertEquals($this->resultRedirectMock, $result);
 }

 public function mockPay($hasForcedState, $forcedState)
 {
     $this->orderMock->expects($this->any())->method('getPayment')->willReturn($this->paymentMock);
     $this->paymentMock->expects($this->once())->method('hasForcedState')->willReturn($hasForcedState);
     if ($hasForcedState) {
         $this->paymentMock->expects($this->once())->method('getForcedState')->willReturn($forcedState);
     } else {
         $this->paymentMock->expects($this->never())->method('getForcedState');
     }
     $this->paymentMock->expects($this->once())->method('pay')->with($this->model)->willReturnSelf();
     $this->eventManagerMock->expects($this->once())->method('dispatch')->with('sales_order_invoice_pay');
 }

 /**
  * @covers \Magento\Braintree\Gateway\Command\CaptureStrategyCommand::execute
  */
 public function testVaultCaptureExecute()
 {
     $paymentData = $this->getPaymentDataObjectMock();
     $subject['payment'] = $paymentData;
     $this->subjectReaderMock->expects(self::once())->method('readPayment')->with($subject)->willReturn($paymentData);
     $this->payment->expects(static::once())->method('getAuthorizationTransaction')->willReturn(true);
     $this->payment->expects(static::once())->method('getId')->willReturn(1);
     $this->buildSearchCriteria();
     $this->transactionRepository->expects(static::once())->method('getTotalCount')->willReturn(1);
     $this->commandPool->expects(static::once())->method('get')->with(CaptureStrategyCommand::VAULT_CAPTURE)->willReturn($this->command);
     $this->strategyCommand->execute($subject);
 }

 public function testCheckAdvancedAcceptingByPaymentMethod()
 {
     $this->initLayoutMock();
     $this->initOrderMock(self::LAST_REAL_ORDER_ID, Order::STATE_NEW);
     $this->initCheckoutSessionMock(self::LAST_REAL_ORDER_ID, true);
     $this->requestMock->expects($this->once())->method('getParam')->with('RESPMSG')->will($this->returnValue('message'));
     $this->blockMock->expects($this->at(0))->method('setData')->with('goto_section', 'paymentMethod')->will($this->returnSelf());
     $this->blockMock->expects($this->at(1))->method('setData')->with('error_msg', __('Your payment has been declined. Please try again.'))->will($this->returnSelf());
     $this->paymentMock->expects($this->once())->method('getMethod')->will($this->returnValue(Config::METHOD_PAYFLOWADVANCED));
     $payflowadvancedReturnUrl = new PayflowadvancedReturnUrl($this->contextMock, $this->checkoutSessionMock, $this->orderFactoryMock, $this->payflowlinkFactoryMock, $this->helperCheckoutMock, $this->loggerMock);
     $payflowadvancedReturnUrl->execute();
 }