aviat/Query
1
1
Fork 0
Code Issues 1 Pull Requests Releases 2 Activity

Test formatting cleanup

Browse Source
This commit is contained in:
Timothy Warren 2012-04-24 14:00:44 -04:00
parent 1849e2d6a8
commit 38aadabc9b
13 changed files with 320 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/core/core.php
View File

@ -29,6 +29,8 @@ class CoreTest extends UnitTestCase {
parent::__construct();
}
// --------------------------------------------------------------------------
/**
* TestPHPVersion function.
*
@ -40,6 +42,8 @@ class CoreTest extends UnitTestCase {
$this->assertTrue(version_compare(PHP_VERSION, "5.2", "ge"));
}
// --------------------------------------------------------------------------
/**
* TestHasPDO function.
*

122
tests/core/db_qb_test.php
View File

@ -18,9 +18,11 @@
*/
abstract class QBTest extends UnitTestCase {
// --------------------------------------------------------------------------
// ! Get Tests
function TestGet()
// --------------------------------------------------------------------------
public function TestGet()
{
if (empty($this->db)) return;
@ -28,8 +30,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestGetLimit()
public function TestGetLimit()
{
if (empty($this->db)) return;
@ -37,8 +41,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestGetLimitSkip()
public function TestGetLimitSkip()
{
if (empty($this->db)) return;
@ -47,7 +53,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestGetWhere()
// --------------------------------------------------------------------------
public function TestGetWhere()
{
if (empty($this->db)) return;
@ -56,7 +64,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestHaving()
// --------------------------------------------------------------------------
public function TestHaving()
{
if (empty($this->db)) return;
@ -70,7 +80,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestOrHaving()
// --------------------------------------------------------------------------
public function TestOrHaving()
{
if (empty($this->db)) return;
@ -84,16 +96,20 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestGetViews()
// --------------------------------------------------------------------------
public function TestGetViews()
{
if (empty($this->db)) return;
$this->assertTrue(is_array($this->db->get_views()));
}
// --------------------------------------------------------------------------
// ! Select Tests
// --------------------------------------------------------------------------
function TestSelectWhereGet()
public function TestSelectWhereGet()
{
if (empty($this->db)) return;
@ -104,8 +120,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestSelectWhereGet2()
public function TestSelectWhereGet2()
{
if (empty($this->db)) return;
@ -116,7 +134,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestSelectMax()
// --------------------------------------------------------------------------
public function TestSelectMax()
{
if (empty($this->db)) return;
@ -126,7 +146,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestSelectMin()
// --------------------------------------------------------------------------
public function TestSelectMin()
{
if (empty($this->db)) return;
@ -136,7 +158,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestSelectAvg()
// --------------------------------------------------------------------------
public function TestSelectAvg()
{
if (empty($this->db)) return;
@ -146,7 +170,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestSelectSum()
// --------------------------------------------------------------------------
public function TestSelectSum()
{
if (empty($this->db)) return;
@ -156,7 +182,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
function TestSelectDistinct()
// --------------------------------------------------------------------------
public function TestSelectDistinct()
{
if (empty($this->db)) return;
@ -166,8 +194,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestSelectGet()
public function TestSelectGet()
{
if (empty($this->db)) return;
@ -176,8 +206,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestSelectFromGet()
public function TestSelectFromGet()
{
if (empty($this->db)) return;
@ -188,8 +220,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestSelectFromLimitGet()
public function TestSelectFromLimitGet()
{
if (empty($this->db)) return;
@ -202,9 +236,11 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
// ! Query modifier tests
// --------------------------------------------------------------------------
function TestOrderBy()
public function TestOrderBy()
{
if (empty($this->db)) return;
@ -219,8 +255,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestOrderByRandom()
public function TestOrderByRandom()
{
if (empty($this->db)) return;
@ -234,8 +272,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestGroupBy()
public function TestGroupBy()
{
if (empty($this->db)) return;
@ -253,8 +293,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestOrWhere()
public function TestOrWhere()
{
if (empty($this->db)) return;
@ -267,8 +309,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestLike()
public function TestLike()
{
if (empty($this->db)) return;
@ -278,8 +322,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestJoin()
public function TestJoin()
{
if (empty($this->db)) return;
@ -290,9 +336,11 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
// ! DB update tests
// --------------------------------------------------------------------------
function TestInsert()
public function TestInsert()
{
if (empty($this->db)) return;
@ -303,8 +351,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestUpdate()
public function TestUpdate()
{
if (empty($this->db)) return;
@ -316,8 +366,10 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
function TestDelete()
public function TestDelete()
{
if (empty($this->db)) return;
@ -326,9 +378,11 @@ abstract class QBTest extends UnitTestCase {
$this->assertIsA($query, 'PDOStatement');
}
// --------------------------------------------------------------------------
// ! Non-data read queries
// --------------------------------------------------------------------------
function TestCountAll()
public function TestCountAll()
{
if (empty($this->db)) return;
$query = $this->db->count_all('create_test');
@ -336,7 +390,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertTrue(is_numeric($query));
}
function TestCountAllResults()
// --------------------------------------------------------------------------
public function TestCountAllResults()
{
if (empty($this->db)) return;
$query = $this->db->count_all_results('create_test');
@ -344,7 +400,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertTrue(is_numeric($query));
}
function TestCountAllResults2()
// --------------------------------------------------------------------------
public function TestCountAllResults2()
{
if (empty($this->db)) return;
@ -358,7 +416,9 @@ abstract class QBTest extends UnitTestCase {
$this->assertTrue(is_numeric($query));
}
function TestNumRows()
// --------------------------------------------------------------------------
public function TestNumRows()
{
$query = $this->db->get('create_test');

22
tests/core/db_test.php
View File

@ -18,22 +18,28 @@
*/
abstract class DBTest extends UnitTestCase {
abstract function TestConnection();
abstract public function TestConnection();
// --------------------------------------------------------------------------
function tearDown()
public function tearDown()
{
$this->db = NULL;
}
// --------------------------------------------------------------------------
function TestGetTables()
public function TestGetTables()
{
if (empty($this->db)) return;
$tables = $this->db->get_tables();
$this->assertTrue(is_array($tables));
}
// --------------------------------------------------------------------------
function TestGetSystemTables()
public function TestGetSystemTables()
{
if (empty($this->db)) return;
@ -41,8 +47,10 @@ abstract class DBTest extends UnitTestCase {
$this->assertTrue(is_array($tables));
}
// --------------------------------------------------------------------------
function TestCreateTransaction()
public function TestCreateTransaction()
{
if (empty($this->db)) return;
@ -50,7 +58,9 @@ abstract class DBTest extends UnitTestCase {
$this->assertTrue($res);
}
function TestBackupData()
// --------------------------------------------------------------------------
public function TestBackupData()
{
$this->assertTrue(is_string($this->db->util->backup_data()));
}

34
tests/core/settings.php
View File

@ -17,7 +17,7 @@
*/
class SettingsTest extends UnitTestCase {
function __construct()
public function __construct()
{
parent::__construct();
$this->settings =& Settings::get_instance();
@ -25,46 +25,62 @@ class SettingsTest extends UnitTestCase {
// Make sure to delete 'foo' if it exists
$this->settings->remove_db('foo');
}
// --------------------------------------------------------------------------
function TestExists()
public function TestExists()
{
$this->assertIsA($this->settings, 'Settings');
}
function TestGetEmptyDBs()
// --------------------------------------------------------------------------
public function TestGetEmptyDBs()
{
$this->assertTrue(is_object($this->settings->get_dbs()));
}
function TestGetNull()
// --------------------------------------------------------------------------
public function TestGetNull()
{
$this->assertFalse(isset($this->settings->foo));
}
function TestSet()
// --------------------------------------------------------------------------
public function TestSet()
{
$bar = $this->settings->foo = 'bar';
$this->assertEqual('bar', $bar);
}
function TestGet()
// --------------------------------------------------------------------------
public function TestGet()
{
$this->assertEqual('bar', $this->settings->foo);
}
function TestSetDBProperty()
// --------------------------------------------------------------------------
public function TestSetDBProperty()
{
$res = $this->settings->__set('dbs', 2);
$this->assertFalse($res);
}
function TestGetEmptyDB()
// --------------------------------------------------------------------------
public function TestGetEmptyDB()
{
$this->assertFalse($this->settings->get_db('foo'));
}
function TestAddDB()
// --------------------------------------------------------------------------
public function TestAddDB()
{
$this->settings->add_db('foo', array());

4
tests/databases/firebird/firebird-qb.php
View File

@ -18,7 +18,7 @@
*/
class FirebirdQBTest extends QBTest {
function __construct()
public function __construct()
{
parent::__construct();
@ -35,6 +35,4 @@ class FirebirdQBTest extends QBTest {
// echo '<hr /> Firebird Queries <hr />';
}
}

72
tests/databases/firebird/firebird.php
View File

@ -20,7 +20,7 @@
*/
class FirebirdTest extends DBTest {
function setUp()
public function setUp()
{
$dbpath = TEST_DIR.DS.'db_files'.DS.'FB_TEST_DB.FDB';
@ -29,24 +29,32 @@ class FirebirdTest extends DBTest {
$this->tables = $this->db->get_tables();
}
function tearDown()
// --------------------------------------------------------------------------
public function tearDown()
{
unset($this->db);
unset($this->tables);
}
// --------------------------------------------------------------------------
function TestConnection()
public function TestConnection()
{
$this->assertIsA($this->db, 'Firebird');
}
function TestGetTables()
// --------------------------------------------------------------------------
public function TestGetTables()
{
$tables = $this->tables;
$this->assertTrue(is_array($tables));
}
function TestGetSystemTables()
// --------------------------------------------------------------------------
public function TestGetSystemTables()
{
$only_system = TRUE;
@ -64,13 +72,17 @@ class FirebirdTest extends DBTest {
$this->assertTrue($only_system);
}
function TestCreateTransaction()
// --------------------------------------------------------------------------
public function TestCreateTransaction()
{
$res = $this->db->beginTransaction();
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
/*function TestCreateTable()
/*public function TestCreateTable()
{
//Attempt to create the table
$sql = $this->db->sql->create_table('create_join', array(
@ -93,16 +105,18 @@ class FirebirdTest extends DBTest {
$this->assertTrue($table_exists);
}*/
// --------------------------------------------------------------------------
function TestTruncate()
public function TestTruncate()
{
$this->db->truncate('create_test');
$this->assertTrue($this->db->affected_rows() > 0);
}
function TestCommitTransaction()
// --------------------------------------------------------------------------
public function TestCommitTransaction()
{
$res = $this->db->beginTransaction();
@ -113,7 +127,9 @@ class FirebirdTest extends DBTest {
$this->assertTrue($res);
}
function TestRollbackTransaction()
// --------------------------------------------------------------------------
public function TestRollbackTransaction()
{
$res = $this->db->beginTransaction();
@ -124,9 +140,9 @@ class FirebirdTest extends DBTest {
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
function TestPreparedStatements()
public function TestPreparedStatements()
{
$sql = <<<SQL
INSERT INTO "create_test" ("id", "key", "val")
@ -137,7 +153,9 @@ SQL;
}
function TestPrepareExecute()
// --------------------------------------------------------------------------
public function TestPrepareExecute()
{
$sql = <<<SQL
INSERT INTO "create_test" ("id", "key", "val")
@ -149,12 +167,16 @@ SQL;
}
function TestPrepareQuery()
// --------------------------------------------------------------------------
public function TestPrepareQuery()
{
$this->assertFalse($this->db->prepare_query('', array()));
}
// --------------------------------------------------------------------------
/*function TestDeleteTable()
/*public function TestDeleteTable()
{
//Attempt to delete the table
$sql = $this->db->sql->delete_table('create_test');
@ -169,22 +191,30 @@ SQL;
$this->assertFalse($table_exists);
}*/
function TestGetSequences()
// --------------------------------------------------------------------------
public function TestGetSequences()
{
$this->assertTrue(is_array($this->db->get_sequences()));
}
function TestGetProcedures()
// --------------------------------------------------------------------------
public function TestGetProcedures()
{
$this->assertTrue(is_array($this->db->get_procedures()));
}
function TestGetFunctions()
// --------------------------------------------------------------------------
public function TestGetpublic functions()
{
$this->assertTrue(is_array($this->db->get_functions()));
$this->assertTrue(is_array($this->db->get_public functions()));
}
function TestGetTriggers()
// --------------------------------------------------------------------------
public function TestGetTriggers()
{
$this->assertTrue(is_array($this->db->get_triggers()));
}

5
tests/databases/mysql/mysql-qb.php
View File

@ -15,7 +15,7 @@
class MySQLQBTest extends QBTest {
function __construct()
public function __construct()
{
parent::__construct();
@ -45,8 +45,9 @@ class MySQLQBTest extends QBTest {
}
}
// --------------------------------------------------------------------------
function TestExists()
public function TestExists()
{
$this->assertTrue(in_array('mysql', pdo_drivers()));
}

53
tests/databases/mysql/mysql.php
View File

@ -20,7 +20,7 @@
*/
class MySQLTest extends DBTest {
function setUp()
public function setUp()
{
// Attempt to connect, if there is a test config file
if (is_file(BASE_DIR . "test_config.json"))
@ -35,20 +35,26 @@ class MySQLTest extends DBTest {
$this->db = new MySQL('host=127.0.0.1;port=3306;dbname=test', 'root');
}
}
// --------------------------------------------------------------------------
function TestExists()
public function TestExists()
{
$this->assertTrue(in_array('mysql', pdo_drivers()));
}
// --------------------------------------------------------------------------
function TestConnection()
public function TestConnection()
{
if (empty($this->db)) return;
$this->assertIsA($this->db, 'MySQL');
}
// --------------------------------------------------------------------------
function TestCreateTable()
public function TestCreateTable()
{
if (empty($this->db)) return;
@ -86,7 +92,9 @@ class MySQLTest extends DBTest {
}
function TestTruncate()
// --------------------------------------------------------------------------
public function TestTruncate()
{
$this->db->truncate('create_test');
$this->db->truncate('create_join');
@ -95,7 +103,9 @@ class MySQLTest extends DBTest {
$cj_query = $this->db->query('SELECT * FROM create_join');
}
function TestPreparedStatements()
// --------------------------------------------------------------------------
public function TestPreparedStatements()
{
if (empty($this->db)) return;
@ -108,8 +118,10 @@ SQL;
$statement->execute();
}
// --------------------------------------------------------------------------
function TestPrepareExecute()
public function TestPrepareExecute()
{
if (empty($this->db)) return;
@ -122,8 +134,10 @@ SQL;
));
}
// --------------------------------------------------------------------------
function TestCommitTransaction()
public function TestCommitTransaction()
{
if (empty($this->db)) return;
@ -135,8 +149,10 @@ SQL;
$res = $this->db->commit();
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
function TestRollbackTransaction()
public function TestRollbackTransaction()
{
if (empty($this->db)) return;
@ -149,24 +165,31 @@ SQL;
$this->assertTrue($res);
}
function TestGetSchemas()
// --------------------------------------------------------------------------
public function TestGetSchemas()
{
$this->assertFalse($this->db->get_schemas());
}
function TestGetsProcedures()
// --------------------------------------------------------------------------
public function TestGetsProcedures()
{
$this->assertTrue(is_array($this->db->get_procedures()));
}
function TestGetTriggers()
// --------------------------------------------------------------------------
public function TestGetTriggers()
{
$this->assertTrue(is_array($this->db->get_triggers()));
}
function TestGetSequences()
// --------------------------------------------------------------------------
public function TestGetSequences()
{
$this->assertFalse($this->db->get_sequences());
}
}
}

6
tests/databases/pgsql/pgsql-qb.php
View File

@ -14,7 +14,7 @@
class PgSQLQBTest extends QBTest {
function __construct()
public function __construct()
{
parent::__construct();
@ -44,8 +44,10 @@ class PgSQLQBTest extends QBTest {
$this->db = new Query_Builder($params);
}
}
// --------------------------------------------------------------------------
function TestExists()
public function TestExists()
{
$this->assertTrue(in_array('pgsql', pdo_drivers()));
}

54
tests/databases/pgsql/pgsql.php
View File

@ -19,12 +19,14 @@
*/
class PgTest extends DBTest {
function __construct()
public function __construct()
{
parent::__construct();
}
// --------------------------------------------------------------------------
function setUp()
public function setUp()
{
// Attempt to connect, if there is a test config file
if (is_file(BASE_DIR . "test_config.json"))
@ -39,20 +41,26 @@ class PgTest extends DBTest {
$this->db = new PgSQL('host=127.0.0.1;port=5432;dbname=test', 'postgres');
}
}
// --------------------------------------------------------------------------
function TestExists()
public function TestExists()
{
$this->assertTrue(in_array('pgsql', pdo_drivers()));
}
// --------------------------------------------------------------------------
function TestConnection()
public function TestConnection()
{
if (empty($this->db)) return;
$this->assertIsA($this->db, 'PgSQL');
}
// --------------------------------------------------------------------------
function TestCreateTable()
public function TestCreateTable()
{
if (empty($this->db)) return;
@ -102,7 +110,9 @@ class PgTest extends DBTest {
}
function TestTruncate()
// --------------------------------------------------------------------------
public function TestTruncate()
{
$this->db->truncate('create_test');
$this->db->truncate('create_join');
@ -111,7 +121,9 @@ class PgTest extends DBTest {
$cj_query = $this->db->query('SELECT * FROM create_join');
}
function TestPreparedStatements()
// --------------------------------------------------------------------------
public function TestPreparedStatements()
{
if (empty($this->db)) return;
@ -124,8 +136,10 @@ SQL;
$statement->execute();
}
// --------------------------------------------------------------------------
function TestPrepareExecute()
public function TestPrepareExecute()
{
if (empty($this->db)) return;
@ -138,8 +152,10 @@ SQL;
));
}
// --------------------------------------------------------------------------
function TestCommitTransaction()
public function TestCommitTransaction()
{
if (empty($this->db)) return;
@ -151,8 +167,10 @@ SQL;
$res = $this->db->commit();
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
function TestRollbackTransaction()
public function TestRollbackTransaction()
{
if (empty($this->db)) return;
@ -165,22 +183,30 @@ SQL;
$this->assertTrue($res);
}
function TestGetSchemas()
// --------------------------------------------------------------------------
public function TestGetSchemas()
{
$this->assertTrue(is_array($this->db->get_schemas()));
}
function TestGetSequences()
// --------------------------------------------------------------------------
public function TestGetSequences()
{
$this->assertTrue(is_array($this->db->get_sequences()));
}
function TestGetsProcedures()
// --------------------------------------------------------------------------
public function TestGetsProcedures()
{
$this->assertTrue(is_array($this->db->get_procedures()));
}
function TestGetTriggers()
// --------------------------------------------------------------------------
public function TestGetTriggers()
{
$this->assertTrue(is_array($this->db->get_triggers()));
}

2
tests/databases/sqlite/sqlite-qb.php
View File

@ -17,7 +17,7 @@
*/
class SQLiteQBTest extends QBTest {
function __construct()
public function __construct()
{
parent::__construct();

62
tests/databases/sqlite/sqlite.php
View File

@ -19,47 +19,61 @@
*/
class SQLiteTest extends UnitTestCase {
function __construct()
public function __construct()
{
parent::__construct();
}
// --------------------------------------------------------------------------
function setUp()
public function setUp()
{
$path = TEST_DIR.DS.'db_files'.DS.'test_sqlite.db';
$this->db = new SQLite($path);
}
// --------------------------------------------------------------------------
function tearDown()
public function tearDown()
{
unset($this->db);
}
// --------------------------------------------------------------------------
function TestConnection()
public function TestConnection()
{
$this->assertIsA($this->db, 'SQLite');
}
// --------------------------------------------------------------------------
function TestGetTables()
public function TestGetTables()
{
$tables = $this->db->get_tables();
$this->assertTrue(is_array($tables));
}
// --------------------------------------------------------------------------
function TestGetSystemTables()
public function TestGetSystemTables()
{
$tables = $this->db->get_system_tables();
$this->assertTrue(is_array($tables));
}
// --------------------------------------------------------------------------
function TestCreateTransaction()
public function TestCreateTransaction()
{
$res = $this->db->beginTransaction();
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
function TestCreateTable()
public function TestCreateTable()
{
//Attempt to create the table
$sql = $this->db->util->create_table('create_test',
@ -92,14 +106,18 @@ class SQLiteTest extends UnitTestCase {
$this->assertTrue(in_array('create_test', $dbs));
}
// --------------------------------------------------------------------------
function TestTruncate()
public function TestTruncate()
{
$this->db->truncate('create_test');
$this->assertIsA($this->db->affected_rows(), 'int');
}
// --------------------------------------------------------------------------
function TestPreparedStatements()
public function TestPreparedStatements()
{
$sql = <<<SQL
INSERT INTO "create_test" ("id", "key", "val")
@ -110,8 +128,10 @@ SQL;
$statement->execute();
}
// --------------------------------------------------------------------------
function TestPrepareExecute()
public function TestPrepareExecute()
{
$sql = <<<SQL
INSERT INTO "create_test" ("id", "key", "val")
@ -122,8 +142,10 @@ SQL;
));
}
// --------------------------------------------------------------------------
function TestCommitTransaction()
public function TestCommitTransaction()
{
$res = $this->db->beginTransaction();
@ -133,8 +155,10 @@ SQL;
$res = $this->db->commit();
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
function TestRollbackTransaction()
public function TestRollbackTransaction()
{
$res = $this->db->beginTransaction();
@ -144,9 +168,11 @@ SQL;
$res = $this->db->rollback();
$this->assertTrue($res);
}
// --------------------------------------------------------------------------
// This is really time intensive ! Run only when needed
/*function TestDeleteTable()
/*public function TestDeleteTable()
{
//Make sure the table exists to delete
$dbs = $this->db->get_tables();
@ -160,13 +186,17 @@ SQL;
$dbs = $this->db->get_tables();
$this->assertFalse(in_array('create_test', $dbs));
}*/
// --------------------------------------------------------------------------
function TestGetDBs()
public function TestGetDBs()
{
$this->assertFalse($this->db->get_dbs());
}
// --------------------------------------------------------------------------
function TestGetSchemas()
public function TestGetSchemas()
{
$this->assertFalse($this->db->get_schemas());
}

BIN
tests/db_files/FB_TEST_DB.FDB
View File

Binary file not shown.