PaymentHandlerTest::testCapture() - Code Metrics - Inspection of "creating more tests" - loevgaard/dandomain-altapay-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( afa46a...04583c )

by Joachim

created 2017-10-25 12:18 UTC

PaymentHandlerTest::testCapture() B

↳ Parent: PaymentHandlerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	24
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	24
rs	8.9713
c	0
b	0
f	0
cc	1
eloc	15
nc	1
nop	0

<?php

namespace Loevgaard\DandomainAltapayBundle\Tests\Handler;

use Loevgaard\AltaPay\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\Handler\PaymentHandler;
use Loevgaard\DandomainAltapayBundle\Manager\PaymentManager;
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, 99.95);
/**
 * @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, null, 100.55);
/**
 * @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(100.55, $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 = $this->getMockForAbstractClass(PaymentLine::class);
        $paymentLine->setPrice(79.96)
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.
}
            ->setVat(25)
            ->setQuantity(1)
            ->setName('name')
            ->setProductNumber('productnumber')
        ;

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $paymentHandler->refund($payment, [$paymentLine], 99.95);
/**
 * @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(99.95, $amount);

        /** @var OrderLine $orderLine */
        $orderLine = $orderLines[0];
        $this->assertSame(99.95, $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.
}

        /** @var PaymentLine|\PHPUnit_Framework_MockObject_MockObject $paymentLine */
        $paymentLine = $this->getMockForAbstractClass(PaymentLine::class);
        $paymentLine->setPrice(100)
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.
}
            ->setVat(25)
            ->setQuantity(1)
            ->setName('name')
            ->setProductNumber('productnumber')
        ;

        $paymentHandler = $this->getPaymentHandler($altapayClient);
        $paymentHandler->refund($payment, [$paymentLine], 80);
/**
 * @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(80.0, $amount);

        /** @var OrderLine $orderLine */
        $orderLine = $orderLines[0];
        $this->assertSame(80.0, $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;
    }

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

        return new PaymentHandler($altapayClient, $paymentManager);
    }
}


Push — master ( afa46a...04583c )

PaymentHandlerTest::testCapture() B

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

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;
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\Handler\PaymentHandler;
14			use Loevgaard\DandomainAltapayBundle\Manager\PaymentManager;
15			use PHPUnit\Framework\TestCase;
16
17			final class PaymentHandlerTest extends TestCase
18			{
19			public function testCapture()
20			{
21			$payment = $this->getPayment();
22			$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...
23
24			$altapayClient = $this->getAltapayClient();
25			$altapayClient
26			->method('captureReservation')
27			->willReturnCallback(function () {
28			$response = $this->getMockBuilder(CaptureReservationResponse::class)
29			->disableOriginalConstructor()
30			->getMock()
31			;
32			$response->method('isSuccessful')->willReturn(true);
33
34			return $response;
35			})
36			;
37
38			$paymentHandler = $this->getPaymentHandler($altapayClient);
39			$res = $paymentHandler->capture($payment, 99.95);

loevgaard / dandomain-altapay-bundle

Push — master ( afa46a...04583c )

PaymentHandlerTest::testCapture() B

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

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