Janisbiz\LightOrm\Tests\Unit\Dms\MySQL\QueryBuilder\Traits\HavingTraitTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ havingData()	0	3	1
A	hp$0 ➔ __construct()	0	4	1
A	hp$0 ➔ testHaving()	0	12	1
A	hp$0 ➔ setUp()	0	38	1
A	hp$0 ➔ buildHavingQueryPartPublic()	0	3	1
	testBuildHavingQueryPart()	0	11	?
A	hp$0 ➔ testBuildHavingQueryPartWhenEmpty()	0	5	1
	testBuildHavingQueryPartWhenEmpty()	0	5	?
A	hp$0 ➔ clearHavingData()	0	3	1
A	hp$0 ➔ testBuildHavingQueryPart()	0	11	1
A	hp$0 ➔ testHavingWithEmptyCondition()	0	6	1
	testHavingWithEmptyCondition()	0	6	?
	setUp()	0	38	?
	testHaving()	0	12	?

<?php declare(strict_types=1);

namespace Janisbiz\LightOrm\Tests\Unit\Dms\MySQL\QueryBuilder\Traits;

use Janisbiz\LightOrm\Dms\MySQL\Enum\ConditionEnum;
use Janisbiz\LightOrm\Dms\MySQL\QueryBuilder\QueryBuilderException;
use Janisbiz\LightOrm\Dms\MySQL\QueryBuilder\Traits\BindTrait;
use Janisbiz\LightOrm\Dms\MySQL\QueryBuilder\Traits\HavingTrait;

class HavingTraitTest extends AbstractTraitTestCase
{
    const HAVING_CONDITION_DEFAULT = [
        'column1 = :value1Bind',
    ];
    const HAVING_CONDITION_BIND_DEFAULT = [
        'value1Bind' => 'value1',
    ];
    const HAVING_CONDITION_EMPTY = '';
    const HAVING_CONDITION = 'column2 = :value2Bind';
    const HAVING_CONDITION_BIND = [
        'value2Bind' => 'value2',
    ];

    /**
     * @var HavingTrait|BindTrait
     */
    private $havingTraitClass;

    public function setUp()
    {
        $this->havingTraitClass = new class (
            HavingTraitTest::HAVING_CONDITION_BIND_DEFAULT,
            HavingTraitTest::HAVING_CONDITION_DEFAULT
        ) {
            use BindTrait;
            use HavingTrait;

            /**
             * @param array $bindDefaultData
             * @param array $havingDefaultData
             */
            public function __construct(array $bindDefaultData, array $havingDefaultData)
            {
                $this->bind = $bindDefaultData;
                $this->having = $havingDefaultData;
            }

            /**
             * @return array
             */
            public function havingData(): array
            {
                return $this->having;
            }

            public function clearHavingData()
            {
                $this->having = [];
            }

            /**
             * @return null|string
             */
            public function buildHavingQueryPartPublic(): ?string
            {
                return $this->buildHavingQueryPart();
            }
        };
    }

    public function testHaving()
    {
        $object = $this->havingTraitClass->having(static::HAVING_CONDITION, static::HAVING_CONDITION_BIND);

It seems like having() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->assertObjectUsesTrait(BindTrait::class, $object);
        $this->assertObjectUsesTrait(HavingTrait::class, $object);
        $this->assertEquals(
            \array_merge(static::HAVING_CONDITION_DEFAULT, [static::HAVING_CONDITION]),
            $this->havingTraitClass->havingData()

It seems like havingData() must be provided by classes using this trait. How about adding it as abstract method to this trait?

The method havingData() does not exist on Janisbiz\LightOrm\Dms\MySQL\QueryBuilder\Traits\HavingTrait. Did you maybe mean having()?

        );
        $this->assertEquals(
            \array_merge(static::HAVING_CONDITION_BIND_DEFAULT, static::HAVING_CONDITION_BIND),
            $this->havingTraitClass->bindData()

It seems like bindData() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        );
    }

    public function testHavingWithEmptyCondition()
    {
        $this->expectException(QueryBuilderException::class);
        $this->expectExceptionMessage('You must pass $condition to having function!');

        $this->havingTraitClass->having(static::HAVING_CONDITION_EMPTY);
    }

    public function testBuildHavingQueryPart()
    {
        $this->havingTraitClass->having(static::HAVING_CONDITION, static::HAVING_CONDITION_BIND);

        $this->assertEquals(
            \sprintf(
                '%s %s',
                ConditionEnum::HAVING,
                \implode(' AND ', \array_unique($this->havingTraitClass->havingData()))
            ),
            $this->havingTraitClass->buildHavingQueryPartPublic()

It seems like buildHavingQueryPartPublic() must be provided by classes using this trait. How about adding it as abstract method to this trait?

The method buildHavingQueryPartPublic() does not exist on Janisbiz\LightOrm\Dms\MySQL\QueryBuilder\Traits\HavingTrait. Did you maybe mean buildHavingQueryPart()?

        );
    }

    public function testBuildHavingQueryPartWhenEmpty()
    {
        $this->havingTraitClass->clearHavingData();

It seems like clearHavingData() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->assertEquals(null, $this->havingTraitClass->buildHavingQueryPartPublic());
    }
}