ApplicationTest\Api\Scalar\MoneyTypeTest

Complexity

Total Complexity

12

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	providerIntValues()	0	6	1
A	testParseValueAsInt()	0	6	1
A	testParseValueThrowsWithInvalidValue()	0	6	1
A	providerValues()	0	7	1
A	testParseLiteral()	0	8	1
A	testParseLiteralAsFloat()	0	8	1
A	testSerialize()	0	7	1
A	testParseValue()	0	7	1
A	testParseValueAsFloat()	0	7	1
A	providerInvalidValues()	0	7	1
A	testParseLiteralThrowsWithInvalidValue()	0	7	1
A	testParseLiteralAsInt()	0	8	1

<?php

declare(strict_types=1);

namespace ApplicationTest\Api\Scalar;

use Application\Api\Scalar\MoneyType;
use GraphQL\Error\Error;
use GraphQL\Language\AST\FloatValueNode;
use GraphQL\Language\AST\IntValueNode;
use GraphQL\Language\AST\StringValueNode;
use Money\Money;
use PHPUnit\Framework\TestCase;

class MoneyTypeTest extends TestCase
{
    public function testSerialize(): void
    {
        $type = new MoneyType();

        $money = Money::CHF('995');
        $actual = $type->serialize($money);
        self::assertSame('9.95', $actual);
    }

    /**
     * @dataProvider providerValues
     */
    public function testParseValue(string $input, Money $expected): void
    {
        $type = new MoneyType();

        $actual = $type->parseValue($input);
        self::assertInstanceOf(Money::class, $actual);
        self::assertTrue($expected->equals($actual));
    }

    /**
     * @dataProvider providerValues
     */
    public function testParseValueAsFloat(string $input, Money $expected): void
    {
        $type = new MoneyType();

        $actual = $type->parseValue((float) $input);
        self::assertInstanceOf(Money::class, $actual);
        self::assertTrue($expected->equals($actual));
    }

    /**
     * @dataProvider providerIntValues
     */
    public function testParseValueAsInt(int $input, Money $expected): void
    {
        $type = new MoneyType();
        $actual = $type->parseValue($input);
        self::assertInstanceOf(Money::class, $actual);
        self::assertSame((int) $expected->getAmount(), (int) $actual->getAmount());
    }

    /**
     * @dataProvider providerValues
     */
    public function testParseLiteral(string $input, Money $expected): void
    {
        $type = new MoneyType();
        $ast = new StringValueNode(['value' => $input]);

        $actual = $type->parseLiteral($ast);
        self::assertInstanceOf(Money::class, $actual);
        self::assertTrue($expected->equals($actual));

$actual of type null|string is incompatible with the type Money\Money expected by parameter $other of Money\Money::equals().

    }

    /**
     * @dataProvider providerValues
     */
    public function testParseLiteralAsFloat(string $input, Money $expected): void
    {
        $type = new MoneyType();
        $ast = new FloatValueNode(['value' => $input]);

        $actual = $type->parseLiteral($ast);
        self::assertInstanceOf(Money::class, $actual);
        self::assertTrue($expected->equals($actual));

$actual of type null|string is incompatible with the type Money\Money expected by parameter $other of Money\Money::equals().

    }

    /**
     * @dataProvider providerIntValues
     */
    public function testParseLiteralAsInt(int $input, Money $expected): void
    {
        $type = new MoneyType();
        $ast = new IntValueNode(['value' => $input]);

        $actual = $type->parseLiteral($ast);
        self::assertInstanceOf(Money::class, $actual);
        self::assertTrue($expected->equals($actual));

$actual of type null|string is incompatible with the type Money\Money expected by parameter $other of Money\Money::equals().

    }

    /**
     * @dataProvider providerInvalidValues
     */
    public function testParseValueThrowsWithInvalidValue(string $invalidValue): void
    {
        $type = new MoneyType();

        $this->expectException(Error::class);
        $type->parseValue($invalidValue);
    }

    /**
     * @dataProvider providerInvalidValues
     */
    public function testParseLiteralThrowsWithInvalidValue(string $invalidValue): void
    {
        $type = new MoneyType();
        $ast = new StringValueNode(['value' => $invalidValue]);

        $this->expectException(Error::class);
        $type->parseLiteral($ast);
    }

    public function providerValues(): array
    {
        return [
            ['2', Money::CHF(200)],
            ['2.95', Money::CHF(295)],
            ['0', Money::CHF(0)],
            ['9.00', Money::CHF(900)],
        ];
    }

    public function providerIntValues(): array
    {
        return [
            [2, Money::CHF(200)],
            [0, Money::CHF(0)],
            [9, Money::CHF(900)],
        ];
    }

    public function providerInvalidValues(): array
    {
        return [
            'non numeric' => ['foo'],
            'too many decimals' => ['1.123'],
            'exponential' => ['1e10'],
            'empty string' => [''],
        ];
    }
}