Add DB condition class tests

tests/framework/db/conditions/BetweenColumnsConditionTest.php

@@ -0,0 +1,191 @@
+<?php
+
+/**
+ * @link https://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license https://www.yiiframework.com/license/
+ */
+
+declare(strict_types=1);
+
+namespace yiiunit\framework\db\conditions;
+
+use yii\base\InvalidArgumentException;
+use yii\db\conditions\BetweenColumnsCondition;
+use yii\db\Expression;
+use yii\db\Query;
+use yiiunit\TestCase;
+
+/**
+ * @group db
+ * @group conditions
+ */
+class BetweenColumnsConditionTest extends TestCase
+{
+    public function testConstructor(): void
+    {
+        $condition = new BetweenColumnsCondition(42, 'BETWEEN', 'min_value', 'max_value');
+
+        $this->assertSame(42, $condition->getValue());
+        $this->assertSame('BETWEEN', $condition->getOperator());
+        $this->assertSame('min_value', $condition->getIntervalStartColumn());
+        $this->assertSame('max_value', $condition->getIntervalEndColumn());
+    }
+
+    public function testConstructorWithNotBetween(): void
+    {
+        $condition = new BetweenColumnsCondition(100, 'NOT BETWEEN', 'low', 'high');
+
+        $this->assertSame('NOT BETWEEN', $condition->getOperator());
+        $this->assertSame(100, $condition->getValue());
+        $this->assertSame('low', $condition->getIntervalStartColumn());
+        $this->assertSame('high', $condition->getIntervalEndColumn());
+    }
+
+    public function testConstructorWithStringValue(): void
+    {
+        $condition = new BetweenColumnsCondition('test', 'BETWEEN', 'col_a', 'col_b');
+
+        $this->assertSame('test', $condition->getValue());
+    }
+
+    public function testConstructorWithNullValue(): void
+    {
+        $condition = new BetweenColumnsCondition(null, 'BETWEEN', 'col_a', 'col_b');
+
+        $this->assertNull($condition->getValue());
+    }
+
+    public function testConstructorWithExpressionColumns(): void
+    {
+        $start = new Expression('MIN(price)');
+        $end = new Expression('MAX(price)');
+        $condition = new BetweenColumnsCondition(50, 'BETWEEN', $start, $end);
+
+        $this->assertSame($start, $condition->getIntervalStartColumn());
+        $this->assertSame($end, $condition->getIntervalEndColumn());
+    }
+
+    public function testConstructorWithQueryColumn(): void
+    {
+        $subQuery = (new Query())->select('time')->from('log')->orderBy('id ASC')->limit(1);
+        $condition = new BetweenColumnsCondition(
+            new Expression('NOW()'),
+            'NOT BETWEEN',
+            $subQuery,
+            'update_time'
+        );
+
+        $this->assertInstanceOf(Expression::class, $condition->getValue());
+        $this->assertSame('NOT BETWEEN', $condition->getOperator());
+        $this->assertInstanceOf(Query::class, $condition->getIntervalStartColumn());
+        $this->assertSame('update_time', $condition->getIntervalEndColumn());
+    }
+
+    public function testConstructorWithExpressionValue(): void
+    {
+        $value = new Expression('NOW()');
+        $condition = new BetweenColumnsCondition($value, 'BETWEEN', 'start_col', 'end_col');
+
+        $this->assertSame($value, $condition->getValue());
+    }
+
+    public function testFromArrayDefinition(): void
+    {
+        $condition = BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [42, 'min_value', 'max_value']);
+
+        $this->assertInstanceOf(BetweenColumnsCondition::class, $condition);
+        $this->assertSame(42, $condition->getValue());
+        $this->assertSame('BETWEEN', $condition->getOperator());
+        $this->assertSame('min_value', $condition->getIntervalStartColumn());
+        $this->assertSame('max_value', $condition->getIntervalEndColumn());
+    }
+
+    public function testFromArrayDefinitionWithNotBetween(): void
+    {
+        $condition = BetweenColumnsCondition::fromArrayDefinition('NOT BETWEEN', ['val', 'start', 'end']);
+
+        $this->assertSame('NOT BETWEEN', $condition->getOperator());
+    }
+
+    public function testFromArrayDefinitionThrowsOnMissingOperands(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage("Operator 'BETWEEN' requires three operands.");
+
+        BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [42, 'min_value']);
+    }
+
+    public function testFromArrayDefinitionThrowsOnEmptyOperands(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenColumnsCondition::fromArrayDefinition('BETWEEN', []);
+    }
+
+    public function testFromArrayDefinitionThrowsOnSingleOperand(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [42]);
+    }
+
+    public function testImplementsConditionInterface(): void
+    {
+        $condition = new BetweenColumnsCondition(1, 'BETWEEN', 'a', 'b');
+
+        $this->assertInstanceOf('yii\db\conditions\ConditionInterface', $condition);
+        $this->assertInstanceOf('yii\db\ExpressionInterface', $condition);
+    }
+
+    public function testFromArrayDefinitionThrowsWhenFirstOperandIsNull(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [null, 'start', 'end']);
+    }
+
+    public function testFromArrayDefinitionThrowsWhenSecondOperandIsNull(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [42, null, 'end']);
+    }
+
+    public function testFromArrayDefinitionThrowsWhenThirdOperandIsNull(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [42, 'start', null]);
+    }
+
+    public function testConstructorWithFloatValue(): void
+    {
+        $condition = new BetweenColumnsCondition(3.14, 'BETWEEN', 'min_col', 'max_col');
+
+        $this->assertSame(3.14, $condition->getValue());
+    }
+
+    public function testConstructorWithZeroValue(): void
+    {
+        $condition = new BetweenColumnsCondition(0, 'BETWEEN', 'a', 'b');
+
+        $this->assertSame(0, $condition->getValue());
+    }
+
+    public function testFromArrayDefinitionPreservesTypes(): void
+    {
+        $condition = BetweenColumnsCondition::fromArrayDefinition('BETWEEN', [1.5, 'start', 'end']);
+
+        $this->assertSame(1.5, $condition->getValue());
+        $this->assertSame('start', $condition->getIntervalStartColumn());
+        $this->assertSame('end', $condition->getIntervalEndColumn());
+    }
+
+    public function testConstructorWithArrayValue(): void
+    {
+        $condition = new BetweenColumnsCondition([1, 2], 'BETWEEN', 'a', 'b');
+
+        $this->assertSame([1, 2], $condition->getValue());
+    }
+}

tests/framework/db/conditions/BetweenConditionTest.php

@@ -0,0 +1,179 @@
+<?php
+
+/**
+ * @link https://www.yiiframework.com/
+ * @copyright Copyright (c) 2008 Yii Software LLC
+ * @license https://www.yiiframework.com/license/
+ */
+
+declare(strict_types=1);
+
+namespace yiiunit\framework\db\conditions;
+
+use yii\base\InvalidArgumentException;
+use yii\db\conditions\BetweenCondition;
+use yii\db\Expression;
+use yiiunit\TestCase;
+
+/**
+ * @group db
+ * @group conditions
+ */
+class BetweenConditionTest extends TestCase
+{
+    public function testConstructor(): void
+    {
+        $condition = new BetweenCondition('age', 'BETWEEN', 18, 65);
+
+        $this->assertSame('age', $condition->getColumn());
+        $this->assertSame('BETWEEN', $condition->getOperator());
+        $this->assertSame(18, $condition->getIntervalStart());
+        $this->assertSame(65, $condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithNotBetween(): void
+    {
+        $condition = new BetweenCondition('price', 'NOT BETWEEN', 100, 500);
+
+        $this->assertSame('price', $condition->getColumn());
+        $this->assertSame('NOT BETWEEN', $condition->getOperator());
+        $this->assertSame(100, $condition->getIntervalStart());
+        $this->assertSame(500, $condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithStringValues(): void
+    {
+        $condition = new BetweenCondition('name', 'BETWEEN', 'A', 'M');
+
+        $this->assertSame('A', $condition->getIntervalStart());
+        $this->assertSame('M', $condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithNullValues(): void
+    {
+        $condition = new BetweenCondition('col', 'BETWEEN', null, null);
+
+        $this->assertNull($condition->getIntervalStart());
+        $this->assertNull($condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithExpression(): void
+    {
+        $start = new Expression('NOW()');
+        $end = new Expression('NOW() + INTERVAL 1 DAY');
+        $condition = new BetweenCondition('created_at', 'BETWEEN', $start, $end);
+
+        $this->assertSame($start, $condition->getIntervalStart());
+        $this->assertSame($end, $condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithExpressionColumn(): void
+    {
+        $column = new Expression('YEAR(created_at)');
+        $condition = new BetweenCondition($column, 'BETWEEN', 2020, 2025);
+
+        $this->assertSame($column, $condition->getColumn());
+    }
+
+    public function testFromArrayDefinition(): void
+    {
+        $condition = BetweenCondition::fromArrayDefinition('BETWEEN', ['age', 18, 65]);
+
+        $this->assertInstanceOf(BetweenCondition::class, $condition);
+        $this->assertSame('age', $condition->getColumn());
+        $this->assertSame('BETWEEN', $condition->getOperator());
+        $this->assertSame(18, $condition->getIntervalStart());
+        $this->assertSame(65, $condition->getIntervalEnd());
+    }
+
+    public function testFromArrayDefinitionWithNotBetween(): void
+    {
+        $condition = BetweenCondition::fromArrayDefinition('NOT BETWEEN', ['price', 0, 100]);
+
+        $this->assertSame('NOT BETWEEN', $condition->getOperator());
+        $this->assertSame('price', $condition->getColumn());
+        $this->assertSame(0, $condition->getIntervalStart());
+        $this->assertSame(100, $condition->getIntervalEnd());
+    }
+
+    public function testFromArrayDefinitionThrowsOnMissingOperands(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage("Operator 'BETWEEN' requires three operands.");
+
+        BetweenCondition::fromArrayDefinition('BETWEEN', ['age', 18]);
+    }
+
+    public function testFromArrayDefinitionThrowsOnEmptyOperands(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenCondition::fromArrayDefinition('BETWEEN', []);
+    }
+
+    public function testFromArrayDefinitionThrowsOnSingleOperand(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenCondition::fromArrayDefinition('BETWEEN', ['age']);
+    }
+
+    public function testImplementsConditionInterface(): void
+    {
+        $condition = new BetweenCondition('col', 'BETWEEN', 1, 10);
+
+        $this->assertInstanceOf('yii\db\conditions\ConditionInterface', $condition);
+        $this->assertInstanceOf('yii\db\ExpressionInterface', $condition);
+    }
+
+    public function testFromArrayDefinitionThrowsWhenFirstOperandIsNull(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenCondition::fromArrayDefinition('BETWEEN', [null, 1, 10]);
+    }
+
+    public function testFromArrayDefinitionThrowsWhenSecondOperandIsNull(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenCondition::fromArrayDefinition('BETWEEN', ['col', null, 10]);
+    }
+
+    public function testFromArrayDefinitionThrowsWhenThirdOperandIsNull(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        BetweenCondition::fromArrayDefinition('BETWEEN', ['col', 1, null]);
+    }
+
+    public function testConstructorWithArrayColumn(): void
+    {
+        $condition = new BetweenCondition(['table', 'column'], 'BETWEEN', 1, 10);
+
+        $this->assertSame(['table', 'column'], $condition->getColumn());
+    }
+
+    public function testFromArrayDefinitionPreservesTypes(): void
+    {
+        $condition = BetweenCondition::fromArrayDefinition('BETWEEN', ['col', 1.5, '100']);
+
+        $this->assertSame(1.5, $condition->getIntervalStart());
+        $this->assertSame('100', $condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithZeroValues(): void
+    {
+        $condition = new BetweenCondition('col', 'BETWEEN', 0, 0);
+
+        $this->assertSame(0, $condition->getIntervalStart());
+        $this->assertSame(0, $condition->getIntervalEnd());
+    }
+
+    public function testConstructorWithEmptyStringColumn(): void
+    {
+        $condition = new BetweenCondition('', 'BETWEEN', 1, 10);
+
+        $this->assertSame('', $condition->getColumn());
+    }
+}