LauLamanApps\IzettleApi\Tests\Unit\Client\Purchase\PaymentBuilderTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	199
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
B	parseArray()	0	28	2
A	parse()	0	17	3
A	cashPaymentTests()	0	4	1
A	cardPaymentTests()	0	15	3
A	getPaymentData()	0	50	1
A	parseNonConfiguredPaymentType()	0	5	1
A	parseNonImplemented()	0	5	1
B	getNonImplementedPaymentData()	0	45	1

<?php

declare(strict_types=1);

namespace LauLamanApps\IzettleApi\Tests\Unit\Client\Purchase;

use LauLamanApps\IzettleApi\API\Purchase\AbstractPayment;
use LauLamanApps\IzettleApi\API\Purchase\Payment\CardPayment;
use LauLamanApps\IzettleApi\API\Purchase\Payment\CashPayment;
use LauLamanApps\IzettleApi\Client\Purchase\PaymentBuilder;
use Money\Currency;
use PHPUnit\Framework\TestCase;
use Ramsey\Uuid\Uuid;

/**
 * @small
 */
final class PaymentBuilderTest extends TestCase
{
    /**
     * @test
     */
    public function parseArray(): void
    {
        $paymentData = [
            [
                "uuid" => (string) Uuid::uuid1(),
                "amount" => 100,
                "type" => PaymentBuilder::CASH,
                "attributes" => [
                    "handedAmount" => 500,
                ]
            ],
            [
                "uuid" => (string) Uuid::uuid1(),
                "amount" => 200,
                "type" => PaymentBuilder::CASH,
                "attributes" => [
                    "handedAmount" => 500,
                ]
            ],
        ];

        $builder = new PaymentBuilder();
        $payments = $builder->buildFromJsonArray($paymentData, new Currency('EUR'));

        foreach ($payments as $payment) {
            self::assertInstanceOf(AbstractPayment::class, $payment);
        }
    }

    /**
     * @test
     * @dataProvider getPaymentData
     */
    public function parse($paymentData, $expectedClass): void
    {
        $builder = new PaymentBuilder();
        $payment = $builder->buildFromJson($paymentData, new Currency('EUR'));

        self::assertInstanceOf(AbstractPayment::class, $payment);
        self::assertInstanceOf($expectedClass, $payment);
        self::assertSame($paymentData['uuid'], (string) $payment->getUuid());
        self::assertSame($paymentData['amount'], (int) $payment->getAmount()->getAmount());

        if ($payment instanceof CashPayment) {
            $this->cashPaymentTests($payment, $paymentData);
        }
        if ($payment instanceof CardPayment) {
            $this->cardPaymentTests($payment, $paymentData);
        }
    }

    private function cashPaymentTests(CashPayment $payment, $paymentData)
    {
        self::assertSame($paymentData['attributes']['handedAmount'], (int) $payment->getHandedAmount()->getAmount());
    }

    private function cardPaymentTests(CardPayment $payment, $paymentData)
    {
        self::assertSame($paymentData['attributes']['cardPaymentEntryMode'], $payment->getCardPaymentEntryMode());
        self::assertSame($paymentData['attributes']['maskedPan'], $payment->getMaskedPan());
        self::assertSame($paymentData['attributes']['referenceNumber'], $payment->getReferenceNumber());
        self::assertSame($paymentData['attributes']['nrOfInstallments'], $payment->getNrOfInstallments());
        self::assertSame($paymentData['attributes']['cardType'], $payment->getCardType());
        self::assertSame($paymentData['attributes']['terminalVerificationResults'], $payment->getTerminalVerificationResults());
        if (array_key_exists('applicationIdentifier', $paymentData['attributes'])) {
            self::assertSame($paymentData['attributes']['applicationIdentifier'], $payment->getApplicationIdentifier());
        }
        if (array_key_exists('applicationName', $paymentData['attributes'])) {
            self::assertSame($paymentData['attributes']['applicationName'], $payment->getApplicationName());
        }
    }

    public function getPaymentData(): array
    {
        return [
            PaymentBuilder::CARD . 1 => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 100,
                    "type" => PaymentBuilder::CARD,
                    "attributes" => [
                        "cardPaymentEntryMode" => "CONTACTLESS_EMV",
                        "maskedPan" => "123456*********1234",
                        "referenceNumber" => "XH3WXTAUFB",
                        "nrOfInstallments" => 0,
                        "cardType" => "MAESTRO",
                        "terminalVerificationResults" => "0000001234",
                        "applicationIdentifier" => "A0000000012345",
                        "applicationName" => "MAESTRO",
                    ]
                ],
                CardPayment::class
            ],
            PaymentBuilder::CARD . 2 => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 100,
                    "type" => PaymentBuilder::CARD,
                    "attributes" => [
                        "cardPaymentEntryMode" => "CONTACTLESS_EMV",
                        "maskedPan" => "123456*********1234",
                        "referenceNumber" => "XH3WXTAUFB",
                        "nrOfInstallments" => 0,
                        "cardType" => "MAESTRO",
                        "terminalVerificationResults" => "0000001234",
                    ]
                ],
                CardPayment::class
            ],
            PaymentBuilder::CASH => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 200,
                    "type" => PaymentBuilder::CASH,
                    "attributes" => [
                        "handedAmount" => 500,
                    ]
                ],
                CashPayment::class
            ],
        ];
    }

    /**
     * @test
     * @expectedException \LauLamanApps\IzettleApi\Client\Exceptions\PaymentTypeNotConfiguredException
     */
    public function parseNonConfiguredPaymentType(): void
    {
        $builder = new PaymentBuilder();
        $builder->buildFromJson(['type' => 'IZETTLE_NON_EXISTENCE'], new Currency('EUR'));
    }

    /**
     * @test
     * @dataProvider getNonImplementedPaymentData
     * @expectedException \Exception
     * @expectedExceptionMessage('Payment type not implemented')
     *
     * We have a test for the non implemented payment types so when someone opens
     * a PR to Add a payment type this test fails and we can write a correct test.
     */
    public function parseNonImplemented($paymentData): void
    {
        $builder = new PaymentBuilder();
        $builder->buildFromJson($paymentData, new Currency('EUR'));
    }

    public function getNonImplementedPaymentData(): array
    {
        return [
            PaymentBuilder::INVOICE => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 300,
                    "type" => PaymentBuilder::INVOICE,
                    "attributes" => [
                        "unknownFields" => true
                    ]
                ]
            ],
            PaymentBuilder::MOBILE => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 400,
                    "type" => PaymentBuilder::MOBILE,
                    "attributes" => [
                        "unknownFields" => true
                    ]
                ]
            ],
            PaymentBuilder::SWISH => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 500,
                    "type" => PaymentBuilder::SWISH,
                    "attributes" => [
                        "unknownFields" => true
                    ]
                ],
            ],
            PaymentBuilder::VIPPS => [
                [
                    "uuid" => (string) Uuid::uuid1(),
                    "amount" => 600,
                    "type" => PaymentBuilder::VIPPS,
                    "attributes" => [
                        "unknownFields" => true
                    ]
                ],
            ],
        ];
    }
}