WhereTraitTest::testBuildWhereQueryPart() - Code Metrics - janisbiz/light-orm - Measure and Improve Code Quality continuously with Scrutinizer

WhereTraitTest::testBuildWhereQueryPart()
last analyzed 2019-08-19 13:17 UTC

↳ Parent: WhereTraitTest
Size

Total Lines	16
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	11
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	16
<?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\WhereTrait;

class WhereTraitTest extends AbstractTraitTestCase
{
    const WHERE_CONDITION_DEFAULT = [
        'column1 = :value1Bind',
    ];
    const WHERE_CONDITION_BIND_DEFAULT = [
        'value1Bind' => 'value1',
    ];
    const WHERE_CONDITION_EMPTY = '';
    const WHERE_CONDITION = 'column2 = :value2Bind';
    const WHERE_CONDITION_BIND = [
        'value2Bind' => 'value2',
    ];
    const WHERE_IN_OR_NOT_IN_COLUMN = 'column3';
    const WHERE_IN_OR_NOT_IN_COLUMN_VALUES = [
        'value3',
        'value4',
    ];

    /**
     * @var BindTrait|WhereTrait
     */
    private $whereTraitClass;
    
    public function setUp()
    {
        $this->whereTraitClass = new class (
            WhereTraitTest::WHERE_CONDITION_BIND_DEFAULT,
            WhereTraitTest::WHERE_CONDITION_DEFAULT
        ) {
            use BindTrait;
            use WhereTrait;

            /**
             * @param array $bindDataDefault
             * @param array $whereDataDefault
             */
            public function __construct(array $bindDataDefault, array $whereDataDefault)
            {
                $this->bind = $bindDataDefault;
                $this->where = $whereDataDefault;
            }

            /**
             * @return array
             */
            public function whereData(): array
            {
                return $this->where;
            }
            
            public function clearWhereData()
            {
                $this->where = [];
            }

            /**
             * @return null|string
             */
            public function buildWhereQueryPartPublic(): ?string
            {
                return $this->buildWhereQueryPart();
            }
        };
    }
    
    public function testWhere()
    {
        $object = $this->whereTraitClass->where(static::WHERE_CONDITION, static::WHERE_CONDITION_BIND);
        $object = $this->whereTraitClass->where(static::WHERE_CONDITION, static::WHERE_CONDITION_BIND);
        $this->assertObjectUsesTrait(BindTrait::class, $object);
        $this->assertObjectUsesTrait(WhereTrait::class, $object);
        $this->assertEquals(
            \array_merge(static::WHERE_CONDITION_DEFAULT, [static::WHERE_CONDITION]),
            $this->whereTraitClass->whereData()
                                    whereData()
        );
        $this->assertEquals(
            \array_merge(static::WHERE_CONDITION_BIND_DEFAULT, static::WHERE_CONDITION_BIND),
            $this->whereTraitClass->bindData()
                                    bindData()
        );
    }

    public function testWhereWithEmptyCondition()
    {
        $this->expectException(QueryBuilderException::class);
        $this->expectExceptionMessage('You must pass $condition name to where method!');

        $this->whereTraitClass->where(static::WHERE_CONDITION_EMPTY);
    }

    public function testWhereIn()
    {
        $object = $this
            ->whereTraitClass
            ->whereIn(
        $object = $this
                static::WHERE_IN_OR_NOT_IN_COLUMN,
                static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES
            )
        ;
        $this->assertObjectUsesTrait(BindTrait::class, $object);
        $this->assertObjectUsesTrait(WhereTrait::class, $object);
        $this->assertEquals(
            \array_merge(
                static::WHERE_CONDITION_DEFAULT,
                [
                    \sprintf(
                        '%s IN (%s)',
                        static::WHERE_IN_OR_NOT_IN_COLUMN,
                        \implode(', ', \array_map(
                            function ($i) {
                                return \sprintf(':%d_%s_In', $i, static::WHERE_IN_OR_NOT_IN_COLUMN);
                            },
                            \array_keys(static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES)
                        ))
                    ),
                ]
            ),
            $this->whereTraitClass->whereData()
        );
        $this->assertEquals(
            \array_merge(
                static::WHERE_CONDITION_BIND_DEFAULT,
                \array_reduce(
                    \array_map(
                        function ($value, $i) {
                            return [
                                \sprintf('%d_%s_In', $i, static::WHERE_IN_OR_NOT_IN_COLUMN) => $value,
                            ];
                        },
                        static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES,
                        \array_keys(static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES)
                    ),
                    'array_merge',
                    []
                )
            ),
            $this->whereTraitClass->bindData()
        );
    }

    public function testWhereNotIn()
    {
        $object = $this
            ->whereTraitClass
            ->whereNotIn(
        $object = $this
                static::WHERE_IN_OR_NOT_IN_COLUMN,
                static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES
            )
        ;
        $this->assertObjectUsesTrait(BindTrait::class, $object);
        $this->assertObjectUsesTrait(WhereTrait::class, $object);
        $this->assertEquals(
            \array_merge(
                static::WHERE_CONDITION_DEFAULT,
                [
                    \sprintf(
                        '%s NOT IN (%s)',
                        static::WHERE_IN_OR_NOT_IN_COLUMN,
                        \implode(', ', \array_map(
                            function ($i) {
                                return \sprintf(':%d_%s_NotIn', $i, static::WHERE_IN_OR_NOT_IN_COLUMN);
                            },
                            \array_keys(static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES)
                        ))
                    ),
                ]
            ),
            $this->whereTraitClass->whereData()
        );
        $this->assertEquals(
            \array_merge(
                static::WHERE_CONDITION_BIND_DEFAULT,
                \array_reduce(
                    \array_map(
                        function ($value, $i) {
                            return [
                                \sprintf('%d_%s_NotIn', $i, static::WHERE_IN_OR_NOT_IN_COLUMN) => $value,
                            ];
                        },
                        static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES,
                        \array_keys(static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES)
                    ),
                    'array_merge',
                    []
                )
            ),
            $this->whereTraitClass->bindData()
        );
    }

    public function testBuildWhereQueryPart()
    {
        $this
            ->whereTraitClass
            ->where(static::WHERE_CONDITION, static::WHERE_CONDITION_BIND)
            ->whereIn(static::WHERE_IN_OR_NOT_IN_COLUMN, static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES)
            ->whereNotIn(static::WHERE_IN_OR_NOT_IN_COLUMN, static::WHERE_IN_OR_NOT_IN_COLUMN_VALUES)
        ;

        $this->assertEquals(
            \sprintf(
                '%s %s',
                ConditionEnum::WHERE,
                \implode(' AND ', \array_unique($this->whereTraitClass->whereData()))
            ),
            $this->whereTraitClass->buildWhereQueryPartPublic()
                                    buildWhereQueryPartPublic()
        );
    }

    public function testBuildWhereQueryPartWhenEmpty()
    {
        $this->whereTraitClass->clearWhereData();
                                clearWhereData();

        $this->assertEquals(null, $this->whereTraitClass->buildWhereQueryPartPublic());
    }
}

janisbiz / light-orm

WhereTraitTest::testBuildWhereQueryPart() last analyzed 2019-08-19 13:17 UTC

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

WhereTraitTest::testBuildWhereQueryPart()
last analyzed 2019-08-19 13:17 UTC
