ilDatabaseAtomBaseTest.php

Go to the documentation of this file.

<?php
/*
        +-----------------------------------------------------------------------------+
        | ILIAS open source                                                           |
        +-----------------------------------------------------------------------------+
        | Copyright (c) 1998-2009 ILIAS open source, University of Cologne            |
        |                                                                             |
        | This program is free software; you can redistribute it and/or               |
        | modify it under the terms of the GNU General Public License                 |
        | as published by the Free Software Foundation; either version 2              |
        | of the License, or (at your option) any later version.                      |
        |                                                                             |
        | This program is distributed in the hope that it will be useful,             |
        | but WITHOUT ANY WARRANTY; without even the implied warranty of              |
        | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
        | GNU General Public License for more details.                                |
        |                                                                             |
        | You should have received a copy of the GNU General Public License           |
        | along with this program; if not, write to the Free Software                 |
        | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
        +-----------------------------------------------------------------------------+
*/

class ilDatabaseAtomBaseTest extends PHPUnit_Framework_TestCase {

        protected $backupGlobals = false;
        protected $ilDBInterfaceGalera;
        protected $ilDBInterfaceInnoDB;


        protected function setUp() {
                require_once("./Services/PHPUnit/classes/class.ilUnitUtil.php");
                ilUnitUtil::performInitialisation();
                require_once('./Services/Database/classes/Atom/class.ilAtomQueryBase.php');
                require_once('./Services/Database/classes/Atom/class.ilAtomQueryTransaction.php');
                require_once('./Services/Database/classes/Atom/class.ilAtomQueryLock.php');
                require_once('./Services/Database/classes/class.ilDBWrapperFactory.php');

                global $ilClientIniFile;
                $this->ilDBInterfaceGalera = ilDBWrapperFactory::getWrapper(ilDBConstants::TYPE_GALERA);
                $this->ilDBInterfaceGalera->initFromIniFile($ilClientIniFile);
                $this->ilDBInterfaceGalera->connect();

                $this->ilDBInterfaceInnoDB = ilDBWrapperFactory::getWrapper(ilDBConstants::TYPE_PDO_MYSQL_INNODB);
                $this->ilDBInterfaceInnoDB->initFromIniFile($ilClientIniFile);
                $this->ilDBInterfaceInnoDB->connect();
        }


        public function testGetInstance() {
                $ilAtomQueryTransaction = $this->ilDBInterfaceGalera->buildAtomQuery();
                $this->assertEquals($ilAtomQueryTransaction->getIsolationLevel(), ilAtomQuery::ISOLATION_SERIALIZABLE);
                $this->assertTrue($ilAtomQueryTransaction instanceof ilAtomQueryTransaction);

                $ilAtomQuery = $this->ilDBInterfaceInnoDB->buildAtomQuery();
                $this->assertEquals($ilAtomQuery->getIsolationLevel(), ilAtomQuery::ISOLATION_SERIALIZABLE);
                $this->assertTrue($ilAtomQuery instanceof ilAtomQueryLock);
        }


        public function testReadUncommited() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
                $other = new ilAtomQueryTransaction($this->ilDBInterfaceGalera, ilAtomQuery::ISOLATION_READ_UNCOMMITED);
                $other->run();
        }


        public function testReadCommited() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
                $other = new ilAtomQueryTransaction($this->ilDBInterfaceGalera, ilAtomQuery::ISOLATION_READ_COMMITED);
                $other->run();
        }


        public function testReadRepeatedRead() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
                $other = new ilAtomQueryTransaction($this->ilDBInterfaceGalera, ilAtomQuery::ISOLATION_REPEATED_READ);
                $other->run();
        }


        public function testAnomalies() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_ANO_NOT_AVAILABLE);
                ilAtomQueryTransaction::checkAnomaly('lorem');
        }


        public function testLevel() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_ISO_WRONG_LEVEL);
                ilAtomQueryTransaction::checkIsolationLevel('lorem');
        }


        public function testRisks() {
                $ilAtomQuery = $this->ilDBInterfaceGalera->buildAtomQuery();
                $ilAtomQuery->addTableLock('object_data');
                $this->assertEquals(array(), $ilAtomQuery->getRisks());
        }


        public function testCallables() {
                require_once('./Services/Database/classes/PDO/class.ilDBPdoMySQL.php');
                require_once('./Services/Database/test/Atom/data/class.ilAtomQueryTestHelper.php');

                $ilAtomQuery = $this->ilDBInterfaceGalera->buildAtomQuery();
                // Working
                $this->assertTrue($ilAtomQuery->checkCallable(function (ilDBInterface $ilDBInterface) { })); // ilDBInterface as first Parameter
                $this->assertTrue($ilAtomQuery->checkCallable(new ilAtomQueryTestHelper())); // Class with implemented __invoke

                // Non working
                $this->assertFalse($ilAtomQuery->checkCallable(function () { })); // No Parameter
                $this->assertFalse($ilAtomQuery->checkCallable(function (ilDBInterface $ilDBInterface, $someOtherParameter) { })); // More than one parameter
                $this->assertFalse($ilAtomQuery->checkCallable(function ($someOtherParameter, ilDBInterface $ilDBInterface) { })); // ilDBInterface not first parameter
                $this->assertFalse($ilAtomQuery->checkCallable(function (ilDBPdoMySQL $ilDBInterface) { })); // not ilDBInterface
                $this->assertFalse($ilAtomQuery->checkCallable(function ($ilDBInterface) { })); // not ilDBInterface
                function noClosure() { }

                $this->assertFalse($ilAtomQuery->checkCallable('noClosure')); // Not a Closure

        }


        public function testWrongIsolationLevel() {
                $this->setExpectedException('ilDatabaseException');
                $ilAtomQuery = new ilAtomQueryTransaction($this->ilDBInterfaceGalera, 'non_existing');
                $ilAtomQuery->addTableLock('il_db_tests_atom');
                $ilAtomQuery->addQueryCallable(function (ilDBInterface $ilDB) {
                        $ilDB->getDBType();
                });
                $ilAtomQuery->run();
        }


        public function testQueryWithFiveException() {
                $counter = 0;
                $max = 5;
                $result = null;
                $query = function (ilDBInterface $ilDBInterface) use (&$counter, &$max, &$result) {
                        if ($counter < $max) {
                                $counter ++;
                                throw new ilDatabaseException('', ilDatabaseException::DB_GENERAL);
                        }
                        $result = $ilDBInterface->listTables();
                };

                $ilAtomQuery = $this->ilDBInterfaceGalera->buildAtomQuery();
                $ilAtomQuery->addQueryCallable($query);
                $ilAtomQuery->addTableLock('object_data');
                $ilAtomQuery->run();
                $this->assertTrue(is_array($result));
        }


        public function testQueryWithTenException() {
                $this->setExpectedException('ilDatabaseException', ilDatabaseException::DB_GENERAL);
                $counter = 0;
                $max = 10;
                $result = null;
                $query = function (ilDBInterface $ilDBInterface) use (&$counter, &$max, &$result) {
                        if ($counter < $max) {
                                $counter ++;
                                throw new ilDatabaseException('', ilDatabaseException::DB_GENERAL);
                        }
                        $result = $ilDBInterface->listTables();
                };

                $ilAtomQuery = $this->ilDBInterfaceGalera->buildAtomQuery();
                $ilAtomQuery->addQueryCallable($query);
                $ilAtomQuery->addTableLock('object_data');

                $ilAtomQuery->run();

                $this->assertTrue(is_null($result));
        }


        public function testWithOutLocks() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_LOCK_NO_TABLE);
                $ilAtomQuery = $this->ilDBInterfaceInnoDB->buildAtomQuery();
                $ilAtomQuery->run();
        }


        public function testWithOutClosures() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_CLOSURE_NONE);
                $ilAtomQuery = $this->ilDBInterfaceInnoDB->buildAtomQuery();
                $ilAtomQuery->addTableLock('object_data');
                $ilAtomQuery->run();
        }


        public function testMultipleClosures() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_CLOSURE_ALREADY_SET);
                $ilAtomQuery = $this->ilDBInterfaceGalera->buildAtomQuery();
                $ilAtomQuery->addTableLock('object_data');
                $ilAtomQuery->addQueryCallable(function (ilDBInterface $ilDBInterface) { });
                $ilAtomQuery->addQueryCallable(function (ilDBInterface $ilDBInterface) { });
        }


        public function testLockSameTable() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_IDENTICAL_TABLES);
                $ilAtomQuery = $this->ilDBInterfaceInnoDB->buildAtomQuery();
                $ilAtomQuery->addTableLock('il_db_tests_atom');
                $ilAtomQuery->addTableLock('il_db_tests_atom');
                $ilAtomQuery->addQueryCallable(function (ilDBInterface $ilDBInterface) { });
                $ilAtomQuery->run();
        }


        public function testLockSameTableWithAlias() {
                $this->setExpectedException('ilAtomQueryException', ilAtomQueryException::DB_ATOM_IDENTICAL_TABLES);
                $ilAtomQuery = $this->ilDBInterfaceInnoDB->buildAtomQuery();
                $ilAtomQuery->addTableLock('il_db_tests_atom')->aliasName('alias_one');
                $ilAtomQuery->addTableLock('il_db_tests_atom')->aliasName('alias_one');
                $ilAtomQuery->addQueryCallable(function (ilDBInterface $ilDBInterface) { });
                $ilAtomQuery->run();
        }
}