PaymentHandlerTest::testRefundAmountMatchesPaymentLineAmount() - Code Metrics - loevgaard/dandomain-altapay-bundle - Measure and Improve Code Quality continuously with Scrutinizer

testRefundAmountMatchesPaymentLineAmount() B
last analyzed 2017-12-13 14:39 UTC

↳ Parent: PaymentHandlerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	42
Code Lines	26

Duplication

Lines	42
Ratio	100 %

Importance

Changes

Metric	Value
dl	42
loc	42
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	26
nc	1
nop	0

<?php

namespace Loevgaard\DandomainAltapayBundle\Tests\Handler;

use Loevgaard\AltaPay\Client\Client;
use Loevgaard\AltaPay\Entity\Transaction;
use Loevgaard\AltaPay\Payload\OrderLine;
use Loevgaard\AltaPay\Payload\RefundCapturedReservation as RefundCapturedReservationPayload;
use Loevgaard\AltaPay\Response\CaptureReservation as CaptureReservationResponse;
use Loevgaard\AltaPay\Response\RefundCapturedReservation as RefundCapturedReservationResponse;
use Loevgaard\DandomainAltapayBundle\Entity\Payment;
use Loevgaard\DandomainAltapayBundle\Entity\PaymentLine;
use Loevgaard\DandomainAltapayBundle\Entity\PaymentRepository;
use Loevgaard\DandomainAltapayBundle\Handler\PaymentHandler;
use Money\Currency;
use Money\Money;
use PHPUnit\Framework\TestCase;

final class PaymentHandlerTest extends TestCase
{
    public function testCapture()
    {
        $payment = $this->getPayment();
        $payment->setAltapayId('altapayid');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $altapayClient = $this->getAltapayClient();
        $altapayClient
            ->method('captureReservation')
            ->willReturnCallback(function () {
                $response = $this->getMockBuilder(CaptureReservationResponse::class)
                    ->disableOriginalConstructor()
                    ->getMock()
                ;
                $response->method('isSuccessful')->willReturn(true);

                return $response;
            })
        ;

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $res = $paymentHandler->capture($payment, new Money(9995, new Currency('DKK')));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertInstanceOf(CaptureReservationResponse::class, $res);
    }

    public function testRefund1()
    {
        $amount = null;
        $orderLines = [];

        $altapayClient = $this->getAltapayClient();
        $altapayClient
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->any())
            ->method('refundCapturedReservation')
            ->willReturnCallback(function ($val) use (&$amount, &$orderLines) {
                /** @var RefundCapturedReservationPayload $val */
                $amount = $val->getAmount();
                $orderLines = $val->getOrderLines();

                $response = $this->getMockBuilder(RefundCapturedReservationResponse::class)
                    ->disableOriginalConstructor()
                    ->getMock()
                ;

                return $response;
            })
        ;

        $payment = $this->getPayment();
        $payment->setAltapayId('altapayid');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $paymentHandler->refund($payment);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertSame(null, $amount);
        $this->assertSame([], $orderLines);
    }

    public function testRefund2()
    {
        $amount = null;
        $orderLines = [];

        $altapayClient = $this->getAltapayClient();
        $altapayClient
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->any())
            ->method('refundCapturedReservation')
            ->willReturnCallback(function ($val) use (&$amount, &$orderLines) {
                /** @var RefundCapturedReservationPayload $val */
                $amount = $val->getAmount();
                $orderLines = $val->getOrderLines();

                $response = $this->getMockBuilder(RefundCapturedReservationResponse::class)
                    ->disableOriginalConstructor()
                    ->getMock()
                ;
                $response->method('isSuccessful')->willReturn(true);

                $transaction = new Transaction();
                $response->method('getTransactions')->willReturn([$transaction]);

                return $response;
            })
        ;

        $payment = $this->getPayment();
        $payment->setAltapayId('altapayid');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $paymentHandler->refund($payment, new Money(10055, new Currency('DKK')));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertEquals(new Money(10055, new Currency('DKK')), $amount);
        $this->assertSame([], $orderLines);
    }

    public function testRefundAmountMatchesPaymentLineAmount()

    {
        $amount = null;
        $orderLines = [];

        $altapayClient = $this->getAltapayClient();
        $altapayClient
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->any())
            ->method('refundCapturedReservation')
            ->willReturnCallback(function ($val) use (&$amount, &$orderLines) {
                /** @var RefundCapturedReservationPayload $val */
                $amount = $val->getAmount();
                $orderLines = $val->getOrderLines();

                $response = $this->getMockBuilder(RefundCapturedReservationResponse::class)
                    ->disableOriginalConstructor()
                    ->getMock()
                ;

                return $response;
            })
        ;

        $payment = $this->getPayment();
        $payment->setAltapayId('altapayid');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        /** @var PaymentLine|\PHPUnit_Framework_MockObject_MockObject $paymentLine */
        $paymentLine = new PaymentLine('productnumber', 'name', 1, new Money('7996', new Currency('DKK')), 25);

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $paymentHandler->refund($payment, new Money(9995, new Currency('DKK')), [$paymentLine]);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertEquals(new Money(9995, new Currency('DKK')), $amount);

        /** @var OrderLine $orderLine */
        $orderLine = $orderLines[0];
        $this->assertEquals(new Money(9995, new Currency('DKK')), $orderLine->getUnitPrice());
        $this->assertSame(25.0, $orderLine->getTaxPercent());
        $this->assertSame(1.0, $orderLine->getQuantity());
        $this->assertSame('name', $orderLine->getDescription());
        $this->assertSame('productnumber', $orderLine->getItemId());
    }

    public function testRefundAmountDoesNotMatchPaymentLineAmount()

    {
        $amount = null;
        $orderLines = [];

        $altapayClient = $this->getAltapayClient();
        $altapayClient
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->any())
            ->method('refundCapturedReservation')
            ->willReturnCallback(function ($val) use (&$amount, &$orderLines) {
                /** @var RefundCapturedReservationPayload $val */
                $amount = $val->getAmount();
                $orderLines = $val->getOrderLines();

                $response = $this->getMockBuilder(RefundCapturedReservationResponse::class)
                    ->disableOriginalConstructor()
                    ->getMock()
                ;

                return $response;
            })
        ;

        $payment = $this->getPayment();
        $payment->setAltapayId('altapayid');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $paymentLine = new PaymentLine('productnumber', 'name', 1, new Money('10000', new Currency('DKK')), 25);

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $paymentHandler->refund($payment, new Money(8000, new Currency('DKK')), [$paymentLine]);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertEquals(new Money(8000, new Currency('DKK')), $amount);

        /** @var OrderLine $orderLine */
        $orderLine = $orderLines[0];
        $this->assertEquals(new Money(8000, new Currency('DKK')), $orderLine->getUnitPrice());
        $this->assertSame(1.0, $orderLine->getQuantity());
        $this->assertSame('refund', $orderLine->getDescription());
        $this->assertSame('refund', $orderLine->getItemId());
    }

    /**
     * @return Payment|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getPayment()
    {
        return $this->getMockForAbstractClass(Payment::class);
    }

    /**
     * @return Client|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getAltapayClient()
    {
        /** @var Client|\PHPUnit_Framework_MockObject_MockObject $altapayClient */
        $altapayClient = $this->getMockBuilder(Client::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        return $altapayClient;
    }

    /**
     * @param $altapayClient
     *
     * @return PaymentHandler
     */
    private function getPaymentHandler($altapayClient): PaymentHandler
    {
        /** @var PaymentRepository|\PHPUnit_Framework_MockObject_MockObject $paymentRepository */
        $paymentRepository = $this->getMockBuilder(PaymentRepository::class)
            ->disableOriginalConstructor()
            ->getMock()
        ;

        return new PaymentHandler($altapayClient, $paymentRepository);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }
}


testRefundAmountMatchesPaymentLineAmount() B
last analyzed 2017-12-13 14:39 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace Loevgaard\DandomainAltapayBundle\Tests\Handler;
4
5			use Loevgaard\AltaPay\Client\Client;
6			use Loevgaard\AltaPay\Entity\Transaction;
7			use Loevgaard\AltaPay\Payload\OrderLine;
8			use Loevgaard\AltaPay\Payload\RefundCapturedReservation as RefundCapturedReservationPayload;
9			use Loevgaard\AltaPay\Response\CaptureReservation as CaptureReservationResponse;
10			use Loevgaard\AltaPay\Response\RefundCapturedReservation as RefundCapturedReservationResponse;
11			use Loevgaard\DandomainAltapayBundle\Entity\Payment;
12			use Loevgaard\DandomainAltapayBundle\Entity\PaymentLine;
13			use Loevgaard\DandomainAltapayBundle\Entity\PaymentRepository;
14			use Loevgaard\DandomainAltapayBundle\Handler\PaymentHandler;
15			use Money\Currency;
16			use Money\Money;
17			use PHPUnit\Framework\TestCase;
18
19			final class PaymentHandlerTest extends TestCase
20			{
21			public function testCapture()
22			{
23			$payment = $this->getPayment();
24			$payment->setAltapayId('altapayid');
			0 ignored issues – show Bug introduced 2017-10-18 14:18 UTC by Report Bug Copy Issue Report The method `setAltapayId` does only exist in `Loevgaard\DandomainAltapayBundle\Entity\Payment`, but not in `PHPUnit_Framework_MockObject_MockObject`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
25
26			$altapayClient = $this->getAltapayClient();
27			$altapayClient
28			->method('captureReservation')
29			->willReturnCallback(function () {
30			$response = $this->getMockBuilder(CaptureReservationResponse::class)
31			->disableOriginalConstructor()
32			->getMock()
33			;
34			$response->method('isSuccessful')->willReturn(true);
35
36			return $response;
37			})
38			;
39

loevgaard / dandomain-altapay-bundle

testRefundAmountMatchesPaymentLineAmount() B last analyzed 2017-12-13 14:39 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

testRefundAmountMatchesPaymentLineAmount() B
last analyzed 2017-12-13 14:39 UTC