class QueryTest

<?php

use Lignite0\ORM\Query;

class QueryTest extends \PHPUnit_Framework_TestCase
{
    public static $queryClassname = 'Lignite0\\ORM\\Query';

    public function testException()
    {
        $this->setExpectedException('InvalidArgumentException');
        throw new \InvalidArgumentException();
    }

    public function testCreate()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
        );

        $this->assertEquals(
            (string)Query::create(),
            'SELECT *'
        );
    }

    public function testSelectAll()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->selectAll()
        );

        $this->assertEquals(
            (string)Query::create()->selectAll(),
            'SELECT *'
        );
    }

    public function testSelectFields()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->selectFields(['userID'])
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['userID']),
            'SELECT userID'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['user' => 'userID']),
            'SELECT userID AS user'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['user' => 'userID', 'group' => 'GroupName']),
            'SELECT userID AS user, GroupName AS group'
        );

        $this->assertEquals(
            (string)Query::create()
                ->selectFields(['user' => 'userID'])
                ->selectFields(['group' => 'GroupName']),
            'SELECT userID AS user, GroupName AS group'
        );

        $this->assertEquals(
            (string)Query::create()
                ->selectFields(['user' => 'userID'])
                ->selectFields(['group' => 'GroupName', 'date' => 'SomeDate']),
            'SELECT userID AS user, GroupName AS group, SomeDate AS date'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['u' => 'userID'])->selectFields(['u' => 'userID']),
            'SELECT userID AS u'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['u' => 'userID'])->selectFields(['u' => 'groupID']),
            'SELECT groupID AS u'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['count' => 'COUNT(userID)']),
            'SELECT COUNT(userID) AS count'
        );
    }

    public function testSelectFieldsException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->select('userID');
    }

    public function testSelectFieldsException2()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->select([]);
    }

    public function testSelectRaw()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->selectRaw()
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw('*'),
            'SELECT *'
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw('     *         '),
            'SELECT *'
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw('userID'),
            'SELECT userID'
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw('userID as u'),
            'SELECT userID AS u'
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw('userID as u, group'),
            'SELECT userID as u, group'
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw("userID as u, group WHERE name = 'foo'"), // don't do that!
            "SELECT userID as u, group WHERE name = 'foo'"
        );

        $this->assertEquals(
            (string)Query::create()->selectRaw('COUNT(userID) AS count'),
            'SELECT COUNT(userID) AS count'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['u' => 'userID'])->selectRaw('COUNT(userID) AS count'),
            'SELECT userID AS u, COUNT(userID) AS count'
        );
    }

    public function testFromTable()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->fromTable('users')
        );

        $this->assertEquals(
            (string)Query::create()->fromTable('users'),
            'SELECT * FROM users'
        );

        $this->assertEquals(
            (string)Query::create()->fromTable('users', 'u'),
            'SELECT * FROM users AS u'
        );

        $this->assertEquals(
            (string)Query::create()->fromTable('users')->fromTable('groups'),
            'SELECT * FROM users, groups'
        );

        $this->assertEquals(
            (string)Query::create()->fromTable('users', 'u')->fromTable('groups'),
            'SELECT * FROM users AS u, groups'
        );
    }

    public function testFromTableException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->fromTable('users AS u');
    }

    public function testFromRaw()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->fromRaw('users')
        );

        $this->assertEquals(
            (string)Query::create()->fromRaw('users'),
            'SELECT * FROM users'
        );

        $this->assertEquals(
            (string)Query::create()->fromRaw('users AS u, groups AS g'),
            'SELECT * FROM users AS u, groups AS g'
        );

        $this->assertEquals(
            (string)Query::create()
                ->fromRaw(
                    '('.(string)Query::create().') AS foo'
                ),
            'SELECT * FROM (SELECT *) AS foo'
        );
    }

    public function testFromRawException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->fromRaw(2);
    }

    public function testFromRawException2()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->fromRaw('');
    }

    public function testFromSubquery()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->fromSubquery(Query::create(), 'alias')
        );

        $this->assertEquals(
            (string)Query::create()->fromSubquery(Query::create(), 'alias'),
            'SELECT * FROM (SELECT *) AS alias'
        );

        $this->assertEquals(
            (string)Query::create()->selectFields(['costCount'])->fromSubquery(
                Query::create()->selectRaw('COUNT(cost) as costCount')->fromTable('users'),
                'alias'
            ),
            'SELECT costCount FROM (SELECT COUNT(cost) as costCount FROM users) AS alias'
        );
    }

    public function testFromSubqueryException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->fromSubquery(Query::create(), '');
    }

    public function testLimit()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->limit(34)
        );

        $this->assertEquals(
            (string)Query::create()->limit(0),
            'SELECT * LIMIT 0'
        );

        $this->assertEquals(
            (string)Query::create()->limit(12),
            'SELECT * LIMIT 12'
        );

        $this->assertEquals(
            (string)Query::create()->limit('16'),
            'SELECT * LIMIT 16'
        );
    }

    public function testLimitException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->limit(-2);
    }

    public function testLimitException2()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->limit([32]);
    }

    public function testOffset()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->offset(34)
        );

        $this->assertEquals(
            (string)Query::create()->offset(0),
            'SELECT * OFFSET 0'
        );

        $this->assertEquals(
            (string)Query::create()->offset(12),
            'SELECT * OFFSET 12'
        );

        $this->assertEquals(
            (string)Query::create()->offset('16'),
            'SELECT * OFFSET 16'
        );

        $this->assertEquals(
            (string)Query::create()->offset(-54),
            'SELECT * OFFSET -54'
        );

        $this->assertEquals(
            (string)Query::create()->offset('-58'),
            'SELECT * OFFSET -58'
        );
    }

    public function testOffsetException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        (string)Query::create()->offset([32]);
    }

    public function testPagination()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->pagination(5, 8)
        );

        $this->assertEquals(
            (string)Query::create()->pagination(4, 10),
            'SELECT * LIMIT 10 OFFSET 30'
        );

        $this->assertEquals(
            (string)Query::create()->pagination(5, 8),
            'SELECT * LIMIT 8 OFFSET 32'
        );

        $this->assertEquals(
            (string)Query::create()->pagination('2', '23'),
            'SELECT * LIMIT 23 OFFSET 23'
        );

        $this->assertEquals(
            (string)Query::create()->pagination('1', '26'),
            'SELECT * LIMIT 26 OFFSET 0'
        );
    }

    public function testPaginationException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->pagination([7, 12]);
    }

    public function testPaginationException2()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->pagination(-5, 4);
    }

    public function testPaginationException3()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->pagination(65, -7);
    }

    public function testPaginationException4()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->pagination(0, 10);
    }

    public function testOrder()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->order('name')
        );

        $this->assertEquals(
            (string)Query::create()->order('name', 'ASC'),
            'SELECT * ORDER BY name ASC'
        );

        $this->assertEquals(
            (string)Query::create()->order('surname', 'desc'),
            'SELECT * ORDER BY surname DESC'
        );

        $this->assertEquals(
            (string)Query::create()->order('surname', 'DeSc'),
            'SELECT * ORDER BY surname DESC'
        );

        $this->assertEquals(
            (string)Query::create()->order('name', 'ASC')->order('surname', 'desc'),
            'SELECT * ORDER BY name ASC, surname DESC'
        );
    }

    public function testOrderException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->order('');
    }

    public function testOrderException2()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->order([]);
    }

    public function testGroup()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->group('name')
        );

        $this->assertEquals(
            (string)Query::create()->group('name'),
            'SELECT * GROUP BY name'
        );

        $this->assertEquals(
            (string)Query::create()->group('name')->group('surname'),
            'SELECT * GROUP BY name, surname'
        );
    }

    public function testGroupException1()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->group('');
    }

    public function testGroupException2()
    {
        $this->setExpectedException('InvalidArgumentException');
        Query::create()->group([]);
    }

    /* WHERE RAW */

    public function testWhereRawWithoutBinds()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereRaw('userID = 1')
        );

        $this->assertEquals(
            (string)Query::create()->whereRaw('userID = 1'),
            'SELECT * WHERE (userID = 1)'
        );

        $this->assertEquals(
            (string)Query::create()->whereRaw('userID = 1 OR userID = 2'),
            'SELECT * WHERE (userID = 1 OR userID = 2)'
        );

        $this->assertEquals(
            (string)Query::create()->whereRaw('userID = 1')->whereRaw('userID = 2'),
            'SELECT * WHERE (userID = 1) AND (userID = 2)'
        );

        $this->assertEquals(
            (string)Query::create()->whereRaw('userID = 1')->whereRaw('userID = 2')->whereRaw('userID = 3 OR userID = 4'),
            'SELECT * WHERE (userID = 1) AND (userID = 2) AND (userID = 3 OR userID = 4)'
        );
    }

    public function testWhereRawWithBinds1()
    {
        $query = Query::create();
        $this->assertEquals(
            (string)$query->whereRaw('userID = ?', 44),
            'SELECT * WHERE (userID = ?)'
        );
        $binds = $query->getBinds();
        $this->assertCount(1, $binds);
        $this->assertContains(44, $binds);
    }

    public function testWhereRawWithBinds2()
    {
        $query = Query::create();
        $this->assertEquals(
            (string)$query->whereRaw('userID = ? OR userID = ?', [43, 54]), // don't do that, use whereIn()
            'SELECT * WHERE (userID = ? OR userID = ?)'
        );
        $binds = $query->getBinds();
        $this->assertCount(2, $binds);
        $this->assertContains(43, $binds);
        $this->assertContains(54, $binds);
        $this->assertEquals(43, array_shift($binds));
        $this->assertEquals(54, array_shift($binds));
    }

    public function testWhereRawWithBinds3()
    {
        $query = Query::create();
        $this->assertEquals(
            (string)$query
                ->whereRaw('userID = ? OR userID = ?', [95, 18])
                ->whereRaw('userID = ? OR userID = ?', [78, 123])
                ->whereRaw('userID = 12')
                ->whereRaw('groupID = ?', 2), // don't do that
            'SELECT * WHERE (userID = ? OR userID = ?) AND (userID = ? OR userID = ?) AND (userID = 12) AND (groupID = ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(5, $binds);
        $this->assertContains(95, $binds);
        $this->assertContains(18, $binds);
        $this->assertContains(78, $binds);
        $this->assertContains(123, $binds);
        $this->assertContains(2, $binds);
        $this->assertEquals(95, array_shift($binds));
        $this->assertEquals(18, array_shift($binds));
        $this->assertEquals(78, array_shift($binds));
        $this->assertEquals(123, array_shift($binds));
        $this->assertEquals(2, array_shift($binds));
    }

    public function testWhereRawWithBinds4()
    {
        $query = Query::create();
        $this->assertEquals(
            (string)$query
                ->whereRaw('username LIKE ? OR username LIKE ?', ['%admin%', '%root%']), // don't do that
            'SELECT * WHERE (username LIKE ? OR username LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(2, $binds);
        $this->assertContains('%admin%', $binds);
        $this->assertContains('%root%',  $binds);
        $this->assertEquals('%admin%', array_shift($binds));
        $this->assertEquals('%root%',  array_shift($binds));
    }

    /* WHERE LIKE */

    public function testWhereLike1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereLike('username', '%ro.t%')
        );
    }

    public function testWhereLike2()
    {
        $this->assertEquals(
            (string)Query::create()->whereLike('username', '%admin%'),
            'SELECT * WHERE (username LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(1, $binds);
        $this->assertContains('%admin%', $binds);
        $this->assertEquals('%admin%', array_shift($binds));
    }

    public function testWhereLike3()
    {
        $this->assertEquals(
            (string)Query::create()->whereLike('username', '%moder%')->whereLike('groupname', '%moderators%'),
            'SELECT * WHERE (username LIKE ?) AND (groupname LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(2, $binds);
        $this->assertContains('%moder%', $binds);
        $this->assertContains('%moderators%', $binds);
        $this->assertEquals('%moder%', array_shift($binds));
        $this->assertEquals('%moderators%', array_shift($binds));
    }

    /* WHERE NOT LIKE */

    public function testWhereNotLike1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereNotLike('username', '%ro.t%')
        );
    }

    public function testWhereNotLike2()
    {
        $this->assertEquals(
            (string)Query::create()->whereNotLike('username', '%admin%'),
            'SELECT * WHERE (username NOT LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(1, $binds);
        $this->assertContains('%admin%', $binds);
        $this->assertEquals('%admin%', array_shift($binds));
    }

    public function testWhereNotLike3()
    {
        $this->assertEquals(
            (string)Query::create()->whereNotLike('username', '%moder%')->whereNotLike('groupname', '%moderators%'),
            'SELECT * WHERE (username NOT LIKE ?) AND (groupname NOT LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(2, $binds);
        $this->assertContains('%moder%', $binds);
        $this->assertContains('%moderators%', $binds);
        $this->assertEquals('%moder%', array_shift($binds));
        $this->assertEquals('%moderators%', array_shift($binds));
    }

    /* WHERE LIKE MANY */

    public function testWhereLikeMany()
    {
        $this->assertEquals(
            (string)Query::create()
                ->whereLikeMany('username', ['%admin%', '%root%', '%null%'])
                ->whereLikeMany('groupname', ['%admins%', '%roots%', '%nuller%']),
            'SELECT * WHERE (username LIKE ? OR username LIKE ? OR username LIKE ?) AND (groupname LIKE ? OR groupname LIKE ? OR groupname LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(6, $binds);
        $this->assertContains('%admin%', $binds);
        $this->assertContains('%root%', $binds);
        $this->assertContains('%null%', $binds);
        $this->assertContains('%admins%', $binds);
        $this->assertContains('%roots%', $binds);
        $this->assertContains('%nuller%', $binds);
        $this->assertEquals('%admin%', array_shift($binds));
        $this->assertEquals('%root%', array_shift($binds));
        $this->assertEquals('%null%', array_shift($binds));
        $this->assertEquals('%admins%', array_shift($binds));
        $this->assertEquals('%roots%', array_shift($binds));
        $this->assertEquals('%nuller%', array_shift($binds));
    }

    /* WHERE NOT LIKE MANY */

    public function testWhereNotLikeMany()
    {
        $this->assertEquals(
            (string)Query::create()
                ->whereNotLikeMany('username', ['%admin%', '%root%', '%null%'])
                ->whereNotLikeMany('groupname', ['%admins%', '%roots%', '%nuller%']),
            'SELECT * WHERE (username NOT LIKE ? OR username NOT LIKE ? OR username NOT LIKE ?) AND (groupname NOT LIKE ? OR groupname NOT LIKE ? OR groupname NOT LIKE ?)'
        );

        $binds = $query->getBinds();
        $this->assertCount(6, $binds);
        $this->assertContains('%admin%', $binds);
        $this->assertContains('%root%', $binds);
        $this->assertContains('%null%', $binds);
        $this->assertContains('%admins%', $binds);
        $this->assertContains('%roots%', $binds);
        $this->assertContains('%nuller%', $binds);
        $this->assertEquals('%admin%', array_shift($binds));
        $this->assertEquals('%root%', array_shift($binds));
        $this->assertEquals('%null%', array_shift($binds));
        $this->assertEquals('%admins%', array_shift($binds));
        $this->assertEquals('%roots%', array_shift($binds));
        $this->assertEquals('%nuller%', array_shift($binds));
    }

    /* WHERE IN */

    public function testWhereIn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereIn('userID', [1])
        );
    }

    public function testWhereIn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->whereIn('userID', [11, 22, 55])
                ->whereIn('groupID', [77, 33, 13]),
            'SELECT * WHERE (userID IN (?, ?, ?)) AND (groupID IN (?, ?, ?))'
        );

        $binds = $query->getBinds();
        $this->assertCount(6, $binds);
        $this->assertContains(11, $binds);
        $this->assertContains(22, $binds);
        $this->assertContains(55, $binds);
        $this->assertContains(77, $binds);
        $this->assertContains(33, $binds);
        $this->assertContains(13, $binds);
        $this->assertEquals(11, array_shift($binds));
        $this->assertEquals(22, array_shift($binds));
        $this->assertEquals(55, array_shift($binds));
        $this->assertEquals(77, array_shift($binds));
        $this->assertEquals(33, array_shift($binds));
        $this->assertEquals(13, array_shift($binds));
    }

    /* WHERE NOT IN */

    public function testWhereNotIn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereNotIn('userID', [1])
        );
    }

    public function testWhereNotIn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->whereIn('userID', [11, 22, 55])
                ->whereIn('groupID', [77, 33, 13]),
            'SELECT * WHERE (userID NOT IN (?, ?, ?)) AND (groupID NOT IN (?, ?, ?))'
        );

        $binds = $query->getBinds();
        $this->assertCount(6, $binds);
        $this->assertContains(11, $binds);
        $this->assertContains(22, $binds);
        $this->assertContains(55, $binds);
        $this->assertContains(77, $binds);
        $this->assertContains(33, $binds);
        $this->assertContains(13, $binds);
        $this->assertEquals(11, array_shift($binds));
        $this->assertEquals(22, array_shift($binds));
        $this->assertEquals(55, array_shift($binds));
        $this->assertEquals(77, array_shift($binds));
        $this->assertEquals(33, array_shift($binds));
        $this->assertEquals(13, array_shift($binds));
    }

    /* WHERE IS NULL */

    public function testWhereIsNull1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereIsNull('userID')
        );
    }

    public function testWhereIsNull2()
    {
        $this->assertEquals(
            (string)Query::create()->from('users')->whereIsNull('groupID'),
            'SELECT * FROM users WHERE (groupID IS NULL)'
        );
    }

    /* WHERE IS NOT NULL */

    public function testWhereIsNotNull1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereIsNotNull('userID')
        );
    }

    public function testWhereIsNotNull2()
    {
        $this->assertEquals(
            (string)Query::create()->from('users')->whereIsNotNull('groupID'),
            'SELECT * FROM users WHERE (groupID IS NOT NULL)'
        );
    }

    /* WHERE IN SUBQUERY */

    public function testWhereInSubquary1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereInSubquary('userID', Query::create())
        );
    }

    public function testWhereInSubquary2()
    {
        $this->assertEquals(
            (string)Query::create()->whereInSubquary(
                'userID',
                Query::create()->whereInSubquary(
                    'groupID',
                    Query::create()->fromTable('groups')
                )
            ),
            'SELECT * WHERE userID IN (SELECT * WHERE groupID IN (SELECT * FROM groups))'
        );
    }

    /* WHERE NOT IN SUBQUERY */

    public function testWhereNotInSubquary1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->whereNotInSubquary('userID', Query::create())
        );
    }

    public function testWhereNotInSubquary2()
    {
        $this->assertEquals(
            (string)Query::create()->whereNotInSubquary(
                'userID',
                Query::create()->whereNotInSubquary(
                    'groupID',
                    Query::create()->fromTable('groups')
                )
            ),
            'SELECT * WHERE userID NOT IN (SELECT * WHERE groupID NOT IN (SELECT * FROM groups))'
        );
    }

    /* JOIN RAW */

    public function testJoinRaw1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->from('users', 'u')->joinRaw('groups AS g')
        );
    }

    public function testJoinRaw2()
    {
        $this->assertInstanceOf(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRaw('groups AS g ON u.groupID = g.groupID'),
            'SELECT * FROM users AS u JOIN groups AS g ON u.groupID = g.groupID'
        );
    }

    public function testJoinRaw3()
    {
        $this->assertInstanceOf(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRaw('groups AS g ON u.groupID = g.groupID')
                ->joinRaw('permission ON g.groupID = permissions.groupID'),
            'SELECT * FROM users AS u JOIN groups AS g ON u.groupID = g.groupID JOIN permission ON g.groupID = permissions.groupID'
        );
    }

    /* JOIN TABLE */

    public function testJoinTable1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinTable('groups', 'g')
        );
    }

    public function testJoinTable2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinTable('groups', 'g'),
            'SELECT * FROM users AS u JOIN groups AS g'
        );
    }

    public function testJoinTable3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')->joinTable('groups', 'g')
                ->joinTable('permissions'),
            'SELECT * FROM users AS u JOIN groups AS g JOIN permissions'
        );
    }

    /* JOIN TABLE ON */

    public function testJoinTableOn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinTableOn('groups', 'g', 'u.groupID = g.groupID')
        );
    }

    public function testJoinTableOn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinTableOn('groups', 'g', 'u.groupID = g.groupID'),
            'SELECT * FROM users AS u JOIN groups AS g ON u.groupID = g.groupID'
        );
    }

    public function testJoinTableOn3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinTableOn('groups', 'g', 'u.groupID = g.groupID')
                ->joinTableOn('permissions', '', 'g.groupID = permissions.groupID'),
            'SELECT * FROM users AS u JOIN groups AS g ON u.groupID = g.groupID JOIN permissions ON g.groupID = permissions.groupID'
        );
    }

    /* JOIN TABLE USING */

    public function testJoinTableUsing1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinTableUsing('groups', 'g', 'groupID')
        );
    }

    public function testJoinTableUsing2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinTableUsing('groups', 'g', 'groupID'),
            'SELECT * FROM users AS u JOIN groups AS g USING (groupID)'
        );
    }

    public function testJoinTableUsing3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinTableUsing('groups', 'g', 'groupID')
                ->joinTableUsing('permissions', '', 'accessID'),
            'SELECT * FROM users AS u JOIN groups AS g USING (groupID) JOIN permissions USING (accessID)'
        );
    }

    /* JOIN SUBQUERY */

    public function testJoinSubquery1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                )
        );
    }

    public function testJoinSubquery2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                ),
            'SELECT * FROM users AS u JOIN (SELECT * FROM groups AS g) AS temp'
        );
    }

    public function testJoinSubquery3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->joinSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                )
                ->joinSubquery(
                    Query::create()
                        ->from('permissions'),
                    'perms'
                ),
            'SELECT * FROM users AS u JOIN (SELECT * FROM groups AS g) AS temp JOIN (SELECT * FROM permissions AS g) AS perms'
        );
    }

    /* JOIN SUBQUERY ON */

    public function testJoinSubqueryOn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                )
        );
    }

    public function testJoinSubqueryOn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                ),
            'SELECT * FROM users AS u JOIN (SELECT * FROM groups AS g) AS temp ON u.groupID = temp.groupID'
        );
    }

    public function testJoinSubqueryOn3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->joinSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                )
                ->joinSubqueryOn(
                    Query::create()
                        ->from('permissions'),
                    'perms',
                    'temp.groupID = perms.groupID'
                ),
            'SELECT * FROM users AS u JOIN (SELECT * FROM groups AS g) AS temp ON u.groupID = temp.groupID JOIN (SELECT * FROM permissions AS g) AS perms ON temp.groupID = perms.groupID'
        );
    }

    /* JOIN SUBQUERY USING */

    public function testJoinSubqueryUsing1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                )
        );
    }

    public function testJoinSubqueryUsing2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                ),
            'SELECT * FROM users AS u JOIN (SELECT * FROM groups AS g) AS temp USING (groupID)'
        );
    }

    public function testJoinSubqueryUsing3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->from('users', 'u')
                ->joinSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                )
                ->joinSubqueryOn(
                    Query::create()
                        ->from('permissions'),
                    'perms',
                    'accessID'
                ),
            'SELECT * FROM users AS u JOIN (SELECT * FROM groups AS g) AS temp USING (groupID) JOIN (SELECT * FROM permissions AS g) AS perms USING (accessID)'
        );
    }

    /* LEFT JOIN RAW */

    public function testJoinLeftRaw1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->from('users', 'u')->joinLeftRaw('groups AS g')
        );
    }

    public function testJoinLeftRaw2()
    {
        $this->assertInstanceOf(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftRaw('groups AS g ON u.groupID = g.groupID'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g ON u.groupID = g.groupID'
        );
    }

    public function testJoinLeftRaw3()
    {
        $this->assertInstanceOf(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftRaw('groups AS g ON u.groupID = g.groupID')
                ->joinLeftRaw('permission ON g.groupID = permissions.groupID'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g ON u.groupID = g.groupID LEFT JOIN permission ON g.groupID = permissions.groupID'
        );
    }

    /* LEFT JOIN TABLE */

    public function testJoinLeftTable1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinLeftTable('groups', 'g')
        );
    }

    public function testJoinLeftTable2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftTable('groups', 'g'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g'
        );
    }

    public function testJoinLeftTable3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')->joinLeftTable('groups', 'g')
                ->joinLeftTable('permissions'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g LEFT JOIN permissions'
        );
    }

    /* LEFT JOIN TABLE ON */

    public function testJoinLeftTableOn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinLeftTableOn('groups', 'g', 'u.groupID = g.groupID')
        );
    }

    public function testJoinLeftTableOn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftTableOn('groups', 'g', 'u.groupID = g.groupID'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g ON u.groupID = g.groupID'
        );
    }

    public function testJoinLeftTableOn3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftTableOn('groups', 'g', 'u.groupID = g.groupID')
                ->joinLeftTableOn('permissions', '', 'g.groupID = permissions.groupID'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g ON u.groupID = g.groupID LEFT JOIN permissions ON g.groupID = permissions.groupID'
        );
    }

    /* LEFT JOIN TABLE USING */

    public function testJoinLeftTableUsing1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinLeftTableUsing('groups', 'g', 'groupID')
        );
    }

    public function testJoinLeftTableUsing2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftTableUsing('groups', 'g', 'groupID'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g USING (groupID)'
        );
    }

    public function testJoinLeftTableUsing3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftTableUsing('groups', 'g', 'groupID')
                ->joinLeftTableUsing('permissions', '', 'accessID'),
            'SELECT * FROM users AS u LEFT JOIN groups AS g USING (groupID) LEFT JOIN permissions USING (accessID)'
        );
    }

    /* LEFT JOIN SUBQUERY */

    public function testJoinLeftSubquery1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinLeftSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                )
        );
    }

    public function testJoinLeftSubquery2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                ),
            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM groups AS g) AS temp'
        );
    }

    public function testJoinLeftSubquery3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->joinLeftSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                )
                ->joinLeftSubquery(
                    Query::create()
                        ->from('permissions'),
                    'perms'
                ),
            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM groups AS g) AS temp LEFT JOIN (SELECT * FROM permissions AS g) AS perms'
        );
    }

    /* LEFT JOIN SUBQUERY ON */

    public function testJoinLeftSubqueryOn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinLeftSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                )
        );
    }

    public function testJoinLeftSubqueryOn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                ),
            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM groups AS g) AS temp ON u.groupID = temp.groupID'
        );
    }

    public function testJoinLeftSubqueryOn3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->joinLeftSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                )
                ->joinLeftSubqueryOn(
                    Query::create()
                        ->from('permissions'),
                    'perms',
                    'temp.groupID = perms.groupID'
                ),
            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM groups AS g) AS temp ON u.groupID = temp.groupID LEFT JOIN (SELECT * FROM permissions AS g) AS perms ON temp.groupID = perms.groupID'
        );
    }

    /* LEFT JOIN SUBQUERY USING */

    public function testJoinLeftSubqueryUsing1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinLeftSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                )
        );
    }

    public function testJoinLeftSubqueryUsing2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinLeftSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                ),
            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM groups AS g) AS temp USING (groupID)'
        );
    }

    public function testJoinLeftSubqueryUsing3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->from('users', 'u')
                ->joinLeftSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                )
                ->joinLeftSubqueryOn(
                    Query::create()
                        ->from('permissions'),
                    'perms',
                    'accessID'
                ),
            'SELECT * FROM users AS u LEFT JOIN (SELECT * FROM groups AS g) AS temp USING (groupID) LEFT JOIN (SELECT * FROM permissions AS g) AS perms USING (accessID)'
        );
    }

    /* RIGHT JOIN RAW */

    public function testJoinRightRaw1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()->from('users', 'u')->joinRightRaw('groups AS g')
        );
    }

    public function testJoinRightRaw2()
    {
        $this->assertInstanceOf(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightRaw('groups AS g ON u.groupID = g.groupID'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g ON u.groupID = g.groupID'
        );
    }

    public function testJoinRightRaw3()
    {
        $this->assertInstanceOf(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightRaw('groups AS g ON u.groupID = g.groupID')
                ->joinRightRaw('permission ON g.groupID = permissions.groupID'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g ON u.groupID = g.groupID RIGHT JOIN permission ON g.groupID = permissions.groupID'
        );
    }

    /* RIGHT JOIN TABLE */

    public function testJoinRightTable1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinRightTable('groups', 'g')
        );
    }

    public function testJoinRightTable2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightTable('groups', 'g'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g'
        );
    }

    public function testJoinRightTable3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')->joinRightTable('groups', 'g')
                ->joinRightTable('permissions'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g RIGHT JOIN permissions'
        );
    }

    /* RIGHT JOIN TABLE ON */

    public function testJoinRightTableOn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinRightTableOn('groups', 'g', 'u.groupID = g.groupID')
        );
    }

    public function testJoinRightTableOn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightTableOn('groups', 'g', 'u.groupID = g.groupID'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g ON u.groupID = g.groupID'
        );
    }

    public function testJoinRightTableOn3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightTableOn('groups', 'g', 'u.groupID = g.groupID')
                ->joinRightTableOn('permissions', '', 'g.groupID = permissions.groupID'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g ON u.groupID = g.groupID RIGHT JOIN permissions ON g.groupID = permissions.groupID'
        );
    }

    /* RIGHT JOIN TABLE USING */

    public function testJoinRightTableUsing1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinRightTableUsing('groups', 'g', 'groupID')
        );
    }

    public function testJoinRightTableUsing2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightTableUsing('groups', 'g', 'groupID'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g USING (groupID)'
        );
    }

    public function testJoinRightTableUsing3()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightTableUsing('groups', 'g', 'groupID')
                ->joinRightTableUsing('permissions', '', 'accessID'),
            'SELECT * FROM users AS u RIGHT JOIN groups AS g USING (groupID) RIGHT JOIN permissions USING (accessID)'
        );
    }

    /* RIGHT JOIN SUBQUERY */

    public function testJoinRightSubquery1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinRightSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                )
        );
    }

    public function testJoinRightSubquery2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                ),
            'SELECT * FROM users AS u RIGHT JOIN (SELECT * FROM groups AS g) AS temp'
        );
    }

    public function testJoinRightSubquery3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->joinRightSubquery(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp'
                )
                ->joinRightSubquery(
                    Query::create()
                        ->from('permissions'),
                    'perms'
                ),
            'SELECT * FROM users AS u RIGHT JOIN (SELECT * FROM groups AS g) AS temp RIGHT JOIN (SELECT * FROM permissions AS g) AS perms'
        );
    }

    /* RIGHT JOIN SUBQUERY ON */

    public function testJoinRightSubqueryOn1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinRightSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                )
        );
    }

    public function testJoinRightSubqueryOn2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                ),
            'SELECT * FROM users AS u RIGHT JOIN (SELECT * FROM groups AS g) AS temp ON u.groupID = temp.groupID'
        );
    }

    public function testJoinRightSubqueryOn3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->joinRightSubqueryOn(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'u.groupID = temp.groupID'
                )
                ->joinRightSubqueryOn(
                    Query::create()
                        ->from('permissions'),
                    'perms',
                    'temp.groupID = perms.groupID'
                ),
            'SELECT * FROM users AS u RIGHT JOIN (SELECT * FROM groups AS g) AS temp ON u.groupID = temp.groupID RIGHT JOIN (SELECT * FROM permissions AS g) AS perms ON temp.groupID = perms.groupID'
        );
    }

    /* RIGHT JOIN SUBQUERY USING */

    public function testJoinRightSubqueryUsing1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::create()
                ->from('users', 'u')
                ->joinRightSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                )
        );
    }

    public function testJoinRightSubqueryUsing2()
    {
        $this->assertEquals(
            (string)Query::create()
                ->from('users', 'u')
                ->joinRightSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                ),
            'SELECT * FROM users AS u RIGHT JOIN (SELECT * FROM groups AS g) AS temp USING (groupID)'
        );
    }

    public function testJoinRightSubqueryUsing3()
    {
        $this->assertEquals(
            (string)Query::create()->from('users', 'u')
                ->from('users', 'u')
                ->joinRightSubqueryUsing(
                    Query::create()
                        ->from('groups', 'g'),
                    'temp',
                    'groupID'
                )
                ->joinRightSubqueryOn(
                    Query::create()
                        ->from('permissions'),
                    'perms',
                    'accessID'
                ),
            'SELECT * FROM users AS u RIGHT JOIN (SELECT * FROM groups AS g) AS temp USING (groupID) RIGHT JOIN (SELECT * FROM permissions AS g) AS perms USING (accessID)'
        );
    }

    /* UNION */

    public function testUnion1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::combineQueriesUsingUnion(
                array(
                    Query::create()->from('users'),
                    Query::create()->from('groups')
                )
            )
        );
    }

    public function testUnion2()
    {
        $this->assertEquals(
            (string)Query::combineQueriesUsingUnion(
                array(
                    Query::create()->selectFields(['groupID'])->from('users'),
                    Query::create()->selectFields(['groupID'])->from('groups')
                )
            ),
            '(SELECT groupID FROM users) UNION (SELECT groupID FROM groups)'
        );
    }

    public function testUnion3()
    {
        $this->assertEquals(
            (string)Query::combineQueriesUsingUnion(
                array(
                    Query::create()->selectFields(['groupID'])->from('users'),
                    Query::create()->selectFields(['groupID'])->from('groups'),
                    Query::create()->selectFields(['groupID'])->from('permissions')
                )
            ),
            '(SELECT groupID FROM users) UNION (SELECT groupID FROM groups) UNION (SELECT groupID FROM permissions)'
        );
    }

    /* UNION ALL */

    public function testUnionAll1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::combineQueriesUsingUnionAll(
                array(
                    Query::create()->from('users'),
                    Query::create()->from('groups')
                )
            )
        );
    }

    public function testUnionAll2()
    {
        $this->assertEquals(
            (string)Query::combineQueriesUsingUnionAll(
                array(
                    Query::create()->selectFields(['groupID'])->from('users'),
                    Query::create()->selectFields(['groupID'])->from('groups')
                )
            ),
            '(SELECT groupID FROM users) UNION ALL (SELECT groupID FROM groups)'
        );
    }

    public function testUnionAll3()
    {
        $this->assertEquals(
            (string)Query::combineQueriesUsingUnion(
                array(
                    Query::create()->selectFields(['groupID'])->from('users'),
                    Query::create()->selectFields(['groupID'])->from('groups'),
                    Query::create()->selectFields(['groupID'])->from('permissions')
                )
            ),
            '(SELECT groupID FROM users) UNION ALL (SELECT groupID FROM groups) UNION ALL (SELECT groupID FROM permissions)'
        );
    }

    /* UNION DISTINCT */

    public function testUnionDistinct1()
    {
        $this->assertInstanceOf(
            self::$queryClassname,
            Query::combineQueriesUsingUnionDistinct(
                array(
                    Query::create()->from('users'),
                    Query::create()->from('groups')
                )
            )
        );
    }

    public function testUnionDistinct2()
    {
        $this->assertEquals(
            (string)Query::combineQueriesUsingUnionDistinct(
                array(
                    Query::create()->selectFields(['groupID'])->from('users'),
                    Query::create()->selectFields(['groupID'])->from('groups')
                )
            ),
            '(SELECT groupID FROM users) UNION DISTINCT (SELECT groupID FROM groups)'
        );
    }

    public function testUnionDistinct3()
    {
        $this->assertEquals(
            (string)Query::combineQueriesUsingUnion(
                array(
                    Query::create()->selectFields(['groupID'])->from('users'),
                    Query::create()->selectFields(['groupID'])->from('groups'),
                    Query::create()->selectFields(['groupID'])->from('permissions')
                )
            ),
            '(SELECT groupID FROM users) UNION DISTINCT (SELECT groupID FROM groups) UNION DISTINCT (SELECT groupID FROM permissions)'
        );
    }
}