bytic / database

tests/Query/SelectTest.php

<?php

/** @noinspection SqlResolve */

/** @noinspection SqlNoDataSourceInspection */

namespace Nip\Database\Tests\Query;

use Mockery as m;
use Nip\Database\Adapters\MySQLi;
use Nip\Database\Connections\Connection;
use Nip\Database\Query\Select;
use Nip\Database\Tests\AbstractTest;

/**
 * Class SelectTest
 * @package Nip\Database\Tests\Query
 *
 * @property Select $object
 */
class SelectTest extends AbstractTest
{
    /**
     * @var \UnitTester

The type UnitTester was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    protected $tester;

    /**
     * @var Connection
     */
    protected $connection;

    /**
     * @var Select
     */
    protected $selectQuery;

    public function testSelectSimple()
    {
        $array = ['id, name as new_name', 'table2.test', 'MAX(pos) as pos'];
        call_user_func_array([$this->selectQuery, 'cols'], $array);
        $this->selectQuery->from('table x')->where('id = 5');

'table x' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        static::assertEquals(
            'SELECT id, name as new_name, table2.test, MAX(pos) as pos FROM table x WHERE id = 5',
            $this->selectQuery->assemble()
        );
    }

    public function testSimpleSelectDistinct()
    {
        $this->selectQuery
            ->cols('id, name')

'id, name' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::cols().

            ->options('distinct')
            ->from('table x')

'table x' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

            ->where('id = 5');
        static::assertEquals(
            "SELECT DISTINCT id, name FROM table x WHERE id = 5",
            $this->selectQuery->assemble()
        );
    }

    public function testWhereAndWhere()
    {
        $this->selectQuery->cols('id, name')->from('table x');

'table x' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

'id, name' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::cols().

        $this->selectQuery->where('id = 5')->where("active = 'yes'");
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes'",
            $this->selectQuery->assemble()
        );
        $this->object->cols('id, name')->from('table x');
        $this->object->where('id = 5')->where("active = 'yes'");
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes'",
            $this->object->assemble()
        );
    }

    public function testWhereOrWhere()
    {
        $this->selectQuery->cols('id, name')->from('table x');

'table x' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

'id, name' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::cols().

        $this->selectQuery->where('id = 5')->orWhere('id = 7');
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 OR id = 7",
            $this->selectQuery->assemble()
        );
        $this->object->cols('id, name')->from('table x');
        $this->object->where('id = 5')->orWhere('id = 7');
        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 OR id = 7",
            $this->object->assemble()
        );
    }

    public function testInitializeCondition()
    {
        $condition = $this->object->getCondition("lorem ipsum");
        static::assertThat($condition, $this->isInstanceOf("Nip\Database\Query\Condition\Condition"));
    }

    public function testNested()
    {
        $this->selectQuery->from("table1");

'table1' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $this->object->from("table1");

        $query = $this->connection->newQuery();
        $query->from("table2");
        $query->where("id != 5");

        $this->object->where("id NOT IN ?", $query);

$query of type Nip\Database\Query\AbstractQuery is incompatible with the type array expected by parameter $values of Nip\Database\Query\AbstractQuery::where().

        static::assertEquals(
            "SELECT * FROM `table1` WHERE id NOT IN (SELECT * FROM `table2` WHERE id != 5)",
            $this->object->assemble()
        );
    }

    public function testUnion()
    {
        $this->object->from("table1");

'table1' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $query = $this->connection->newQuery();
        $query->from("table2");

        $union = $this->object->union($query);

        static::assertEquals("SELECT * FROM `table1` UNION SELECT * FROM `table2`", $union->assemble());
    }

    public function testJoinTableName()
    {
        $this->object->from("table1");

'table1' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $this->object->join("table2", ['id', 'id_table1']);

array('id', 'id_table1') of type array<integer,string> is incompatible with the type boolean|string expected by parameter $on of Nip\Database\Query\Select::join().

        static::assertEquals(
            "SELECT * FROM `table1` JOIN `table2` ON `table1`.`id` = `table2`.`id_table1`",
            $this->object->assemble()
        );
    }

    public function testJoinTableNameWithAlias()
    {
        $this->object->from("table1");

'table1' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $this->object->join(["table2", "alias"], ['id', 'id_table1']);

array('id', 'id_table1') of type array<integer,string> is incompatible with the type boolean|string expected by parameter $on of Nip\Database\Query\Select::join().

        static::assertEquals(
            "SELECT * FROM `table1` JOIN `table2` AS `alias` ON `table1`.`id` = `table2`.`id_table1`",
            $this->object->assemble()
        );
    }

    public function testJoinSubQuery()
    {
        $this->object->from("table1");

'table1' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $query = $this->connection->newQuery();
        $query->from("table2");

        $this->object->join([$query, "alias"], ['id', 'id_table1']);

array('id', 'id_table1') of type array<integer,string> is incompatible with the type boolean|string expected by parameter $on of Nip\Database\Query\Select::join().

        static::assertEquals(
            'SELECT * FROM `table1` JOIN (SELECT * FROM `table2`) AS `alias` ON `table1`.`id` = `alias`.`id_table1`',
            $this->object->assemble()
        );
    }

    public function testHasPart()
    {
        $this->object->cols('id, name');

'id, name' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::cols().

        self::assertTrue($this->object->hasPart('cols'));

        $this->object->setCols('id, name');

'id, name' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::setCols().

        self::assertTrue($this->object->hasPart('cols'));

        $this->object->limit('');

'' of type string is incompatible with the type integer expected by parameter $start of Nip\Database\Query\AbstractQuery::limit().

        self::assertFalse($this->object->hasPart('limit'));

        $this->object->limit('6');
        self::assertTrue($this->object->hasPart('limit'));

        self::assertFalse($this->object->hasPart('where'));
    }

    public function testLimit()
    {
        $this->object->cols('id, name')->from('table x');

'id, name' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::cols().

'table x' of type string is incompatible with the type array expected by parameter $| of Nip\Database\Query\AbstractQuery::from().

        $this->object->where('id = 5')->where("active = 'yes'");
        $this->object->limit(5);

        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes' LIMIT 5",
            $this->object->assemble()
        );

        $this->object->limit(5, 10);

10 of type integer is incompatible with the type boolean expected by parameter $offset of Nip\Database\Query\AbstractQuery::limit().

        static::assertEquals(
            "SELECT id, name FROM table x WHERE id = 5 AND active = 'yes' LIMIT 5,10",
            $this->object->assemble()
        );
    }

    protected function setUp(): void
    {
        parent::setUp();
        $this->object = new Select();

        $adapterMock = m::mock(MySQLi::class)->makePartial();
        $adapterMock->shouldReceive('cleanData')->andReturnUsing(function ($data) {
            return $data;
        });
        $this->connection = new Connection(false);

false of type false is incompatible with the type Closure|PDO expected by parameter $pdo of Nip\Database\Connections\Connection::__construct().

        $this->connection->setAdapter($adapterMock);
        $this->object->setManager($this->connection);

        $this->selectQuery = new Select();
    }
}