hiqdev\php\billing\tests\behat\bootstrap\FeatureContext

Complexity

Total Complexity

26

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	priceIs()	0	8	1
A	actionIs()	0	8	1
A	formulaIs()	0	4	1
A	getFormulaEngine()	0	8	2
A	actionDateIs()	0	4	1
A	errorIs()	0	4	1
A	emptyCharge()	0	4	1
A	chargeWithSum()	0	4	1
A	chargeWithReason()	0	4	1
A	chargeIs()	0	8	2
A	calculateCharges()	0	7	1
A	expectError()	0	12	3
A	isExpectedError()	0	4	1
A	startsWith()	0	4	1
B	assertCharge()	0	15	5
A	ensureNo()	0	10	2

<?php
/**
 * PHP Billing Library
 *
 * @link      https://github.com/hiqdev/php-billing
 * @package   php-billing
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017-2018, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\php\billing\tests\behat\bootstrap;

use Behat\Behat\Context\Context;
use Closure;
use DateTimeImmutable;
use hiqdev\php\billing\action\Action;
use hiqdev\php\billing\charge\Charge;
use hiqdev\php\billing\charge\ChargeInterface;
use hiqdev\php\billing\customer\Customer;
use hiqdev\php\billing\formula\FormulaEngine;
use hiqdev\php\billing\price\SinglePrice;
use hiqdev\php\billing\target\Target;
use hiqdev\php\billing\type\Type;
use hiqdev\php\units\Quantity;
use Money\Currencies\ISOCurrencies;
use Money\Parser\DecimalMoneyParser;
use NumberFormatter;
use PHPUnit\Framework\Assert;

/**
 * Defines application features from the specific context.
 */
class FeatureContext implements Context
{
    protected $engine;

    /** @var Customer */
    protected $customer;
    /**
     * @var \hiqdev\php\billing\price\PriceInterface|\hiqdev\php\billing\charge\FormulaChargeModifierTrait
     *
     * TODO: FormulaChargeModifierTrait::setFormula() must be moved to interface
     */
    protected $price;

    /** @var string */
    protected $formula;

    /**
     * @var \hiqdev\php\billing\action\ActionInterface|\hiqdev\php\billing\action\AbstractAction
     */
    protected $action;
    /**
     * @var ChargeInterface[]
     */
    protected $charges;

    /** @var \Money\MoneyParser */
    protected $moneyParser;

    /** @var string */
    protected $expectedError;

    /**
     * Initializes context.
     */
    public function __construct()
    {
        $this->customer = new Customer(null, 'somebody');
        $this->moneyParser = new DecimalMoneyParser(new ISOCurrencies());
    }

    /**
     * @Given /(\S+) (\S+) price is ([0-9.]+) (\w+) per (\w+)/
     */
    public function priceIs($target, $type, $sum, $currency, $unit)
    {
        $type = new Type(Type::ANY, $type);
        $target = new Target(Target::ANY, $target);
        $quantity = Quantity::create($unit, 0);
        $sum = $this->moneyParser->parse($sum, $currency);
        $this->price = new SinglePrice(null, $type, $target, null, $quantity, $sum);
    }

    /**
     * @Given /action is (\S+) (\w+) ([0-9.]+) (\S+)/
     */
    public function actionIs($target, $type, $amount, $unit)
    {
        $type = new Type(Type::ANY, $type);
        $target = new Target(Target::ANY, $target);
        $quantity = Quantity::create($unit, $amount);
        $time = new DateTimeImmutable();
        $this->action = new Action(null, $type, $target, $quantity, $this->customer, $time);
    }

    /**
     * @Given /formula is (.+)/
     * @param string $formula
     */
    public function formulaIs(string $formula): void
    {
        $this->formula = $formula;
    }

    protected function getFormulaEngine()
    {
        if ($this->engine === null) {
            $this->engine = new FormulaEngine();
        }

        return $this->engine;
    }

    /**
     * @When /action date is ([0-9.-]+)/
     * @param string $date
     * @throws \Exception
     */
    public function actionDateIs(string $date): void
    {
        $this->action->setTime(new DateTimeImmutable($date));

The method setTime does only exist in hiqdev\php\billing\action\AbstractAction, but not in hiqdev\php\billing\action\ActionInterface.

    }

    /**
     * @Then /^error is (.+)$/
     * @param string $error
     */
    public function errorIs(string $error): void
    {
        $this->expectedError = $error;
    }

    /**
     * @Then /^(\w+) charge is $/
     * @param string $numeral
     */
    public function emptyCharge(string $numeral): void
    {
        $this->chargeIs($numeral);
    }

    /**
     * @Then /^(\w+) charge is (\S+) +([0-9.]+) ([A-Z]{3})$/
     */
    public function chargeWithSum($numeral, $type = null, $sum = null, $currency = null): void
    {
        $this->chargeIs($numeral, $type, $sum, $currency);
    }

    /**
     * @Then /^(\w+) charge is (\S+) +([0-9.]+) ([A-Z]{3}) reason (.+)/
     */
    public function chargeWithReason($numeral, $type = null, $sum = null, $currency = null, $reason = null): void
    {
        $this->chargeIs($numeral, $type, $sum, $currency, $reason);
    }

    public function chargeIs($numeral, $type = null, $sum = null, $currency = null, $reason = null): void
    {
        $no = $this->ensureNo($numeral);
        if ($no === 0) {
            $this->calculateCharges();
        }
        $this->assertCharge($this->charges[$no] ?? null, $type, $sum, $currency, $reason);
    }

    /**
     * @When /^calculating charges$/
     */
    public function calculateCharges(): void
    {
        $this->expectError(function () {
            $this->price->setFormula($this->getFormulaEngine()->build($this->formula));

The method setFormula does only exist in hiqdev\php\billing\charge\FormulaChargeModifierTrait, but not in hiqdev\php\billing\price\PriceInterface.

            $this->charges = $this->price->calculateCharges($this->action);

The method calculateCharges does only exist in hiqdev\php\billing\price\PriceInterface, but not in hiqdev\php\billing\charge\FormulaChargeModifierTrait.

        });
    }

    public function expectError(Closure $closure): void
    {
        try {
            call_user_func($closure);
        } catch (\Exception $e) {
            if ($this->isExpectedError($e)) {
                $this->expectedError = null;
            } else {
                throw $e;
            }
        }
    }

    protected function isExpectedError(\Exception $e): bool
    {
        return $this->startsWith($e->getMessage(), $this->expectedError);
    }

    protected function startsWith(string $string, string $prefix = null): bool
    {
        return strncmp($string, $prefix, strlen($prefix)) === 0;
    }

    /**
     * @param ChargeInterface|null $charge
     * @param string|null $type
     * @param string|null $sum
     * @param string|null $currency
     * @param string|null $reason
     */
    public function assertCharge($charge, $type, $sum, $currency, $reason): void
    {
        if (empty($type) && empty($sum) && empty($currency)) {
            Assert::assertNull($charge);

            return;
        }
        Assert::assertInstanceOf(Charge::class, $charge);
        Assert::assertSame($type, $charge->getPrice()->getType()->getName());

It seems like $charge is not always an object, but can also be of type null. Maybe add an additional type check?

        $money = $this->moneyParser->parse($sum, $currency);
        Assert::assertEquals($money, $charge->getSum()); // TODO: Should we add `getSum()` to ChargeInterface?
        if ($reason !== null) {
            Assert::assertSame($reason, $charge->getComment()); // TODO: Should we add `getComment()` to ChargeInterface?
        }
    }

    private function ensureNo(string $numeral): int
    {
        $formatter = new NumberFormatter('en_EN', NumberFormatter::SPELLOUT);
        $result = $formatter->parse($numeral);
        if ($result === false) {
            throw new \Exception("Wrong numeral '$numeral'");
        }

        return --$result;
    }
}