DatabaseTest::testSetDbType() - Code Metrics - Inspection of "Database coverage improvement" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 855968...4d0f3d )

by Jean-Christophe
created 2019-01-25 02:00 UTC
DatabaseTest::testSetDbType() A

↳ Parent: DatabaseTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	1
Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	4
rs	10
c	3
b	0
f	1
<?php
use Ubiquity\db\Database;
use Ubiquity\cache\database\TableCache;
use Ubiquity\exceptions\CacheException;

require_once 'Ubiquity/db/Database.php';

/**
 * Database test case.
 *
 * @covers \Ubiquity\db\Database
 *
 */
class DatabaseTest extends \Codeception\Test\Unit {

	/**
	 *
	 * @var Database
	 */
	private $database;
	private $db_server;
	const DB_NAME = 'messagerie';
	const DB_TYPE = 'mysql';

	/**
	 * Prepares the environment before running a test.
	 */
	protected function _before() {
		if (! defined ( 'ROOT' )) {
			define ( 'ROOT', __DIR__ );
			define ( 'DS', DIRECTORY_SEPARATOR );
		}
		$ip = getenv ( 'SERVICE_MYSQL_IP' );
		if ($ip === false) {
			$ip = '127.0.0.1';
		}
		$this->db_server = $ip;
		$this->database = new Database ( self::DB_TYPE, self::DB_NAME, $this->db_server );
	}

	/**
	 * Cleans up the environment after running a test.
	 */
	protected function _after() {
		$this->database = null;
	}

	protected function beforeQuery() {
		if (! $this->database->isConnected ())
			$this->database->connect ();
	}

	/**
	 * Tests Database->__construct()
	 *
	 * @covers \Ubiquity\db\Database::<private>
	 */
	public function test__construct() {
		$this->assertEquals ( self::DB_NAME, $this->database->getDbName () );
		$this->assertEquals ( '3306', $this->database->getPort () );
		$db = new Database ( self::DB_TYPE, self::DB_NAME, $this->db_server, 3306, 'root', '', [ "quote" => "`" ], TableCache::class );
		$this->assertTrue ( $db->connect () );
		$db = new Database ( self::DB_TYPE, self::DB_NAME, $this->db_server, 3306, 'root', '', [ "quote" => "`" ], function () {
		$db = new Database ( self::DB_TYPE, self::DB_NAME, $this->db_server, 3306, 'root', '', [ "quote" => "`" ], /** @scrutinizer ignore-type */ function () {
			return new TableCache ();
		} );
		$this->assertTrue ( $db->connect () );
		$this->expectException ( CacheException::class );
		$db = new Database ( self::DB_TYPE, self::DB_NAME, $this->db_server, 3306, 'root', '', [ "quote" => "`" ], "notExistingClass" );
		$this->assertTrue ( $db->connect () );
	}

	/**
	 * Tests Database->connect()
	 */
	public function testConnect() {
		$this->assertFalse ( $this->database->isConnected () );
		$this->assertFalse ( $this->database->ping () );
		$this->assertTrue ( $this->database->connect () );
		$this->assertTrue ( $this->database->isConnected () );
		$this->assertTrue ( $this->database->ping () );
		$this->database->setUser ( 'nobody' );
		$this->assertFalse ( $this->database->connect () );
	}

	/**
	 * Tests Database->setters
	 */
	public function testSetters() {
		$this->database->setDbName ( 'test' );
		$this->assertEquals ( 'test', $this->database->getDbName () );
		$this->database->setDbType ( 'mongo' );
		$this->assertEquals ( 'mongo', $this->database->getDbType () );
		$options = [ "a" => true,"b" => "test" ];
		$this->database->setOptions ( $options );
		$this->assertEquals ( $options, $this->database->getOptions () );
		$this->database->setPassword ( 'password' );
		$this->assertEquals ( 'password', $this->database->getPassword () );
		$this->database->setPort ( 3307 );
		$this->assertEquals ( 3307, $this->database->getPort () );
		$this->database->setServerName ( 'local' );
		$this->assertEquals ( 'local', $this->database->getServerName () );
		$this->database->setUser ( 'user' );
		$this->assertEquals ( 'user', $this->database->getUser () );
	}

	/**
	 * Tests Database->getDSN()
	 */
	public function testGetDSN() {
		$db = new Database ( self::DB_TYPE, "dbname" );
		$dsn = $db->getDSN ();
		$this->assertEquals ( self::DB_TYPE . ':dbname=dbname;host=127.0.0.1;charset=UTF8;port=3306', $dsn );
		$db->setDbType ( "mongo" );
		$this->assertEquals ( 'mongo:dbname=dbname;host=127.0.0.1;charset=UTF8;port=3306', $db->getDSN () );
		$db->setServerName ( "localhost" );
		$this->assertEquals ( 'mongo:dbname=dbname;host=localhost;charset=UTF8;port=3306', $db->getDSN () );
		$db->setPort ( 23 );
		$this->assertEquals ( 'mongo:dbname=dbname;host=localhost;charset=UTF8;port=23', $db->getDSN () );
	}

	/**
	 * Tests Database->query()
	 */
	public function testQuery() {
		$this->beforeQuery ();
		$this->assertNotFalse ( $this->database->query ( "SELECT 1" ) );
		$st = $this->database->query ( "SELECT * from `user` limit 0,1" );
		$this->assertInstanceOf ( PDOStatement::class, $st );
	}

	/**
	 * Tests Database->prepareAndExecute()
	 */
	public function testPrepareAndExecute() {
		$this->beforeQuery ();
		$response = $this->database->prepareAndExecute ( "user", "WHERE `email`='[email protected]'", [ "email","firstname" ] );
		$this->assertEquals ( sizeof ( $response ), 1 );
		$row = current ( $response );
		$this->assertEquals ( "[email protected]", $row ['email'] );
		$this->assertEquals ( "Benjamin", $row ['firstname'] );
		$this->assertArrayNotHasKey ( 'lastname', $row );
		$this->expectException ( Error::class );
		$this->database->prepareAndExecute ( "users", "WHERE `email`='[email protected]'", [ "email","firstname" ], null, true );
		$db = new Database ( self::DB_TYPE, self::DB_NAME, $this->db_server, 3306, 'root', '', [ "quote" => "`" ], TableCache::class );
		$db->connect ();
		$response = $db->prepareAndExecute ( "user", "WHERE `email`='[email protected]'", [ "email","firstname" ], null, true );
		$this->assertEquals ( sizeof ( $response ), 1 );
		$row = current ( $response );
		$this->assertEquals ( "[email protected]", $row ['email'] );
		$response = $db->prepareAndExecute ( "user", "WHERE `email`= ?", [ "email","firstname" ], [ '[email protected]' ], true );
		$this->assertEquals ( sizeof ( $response ), 1 );
		$row = current ( $response );
		$this->assertEquals ( "[email protected]", $row ['email'] );
	}

	/**
	 * Tests Database->prepareAndFetchAll()
	 */
	public function testPrepareAndFetchAll() {
		$this->beforeQuery ();
		$this->assertNotFalse ( $this->database->prepareAndFetchAll ( "SELECT 1" ) );
		$resp = $this->database->prepareAndFetchAll ( "select * from `user`" );
		$this->assertEquals ( 101, sizeof ( $resp ) );
		$row = current ( $resp );
		$this->assertEquals ( 7, sizeof ( $row ) );
		$resp = $this->database->prepareAndFetchAll ( "select * from `user` where email= ?", [ "[email protected]" ] );
		$row = current ( $resp );
		$this->assertEquals ( "[email protected]", $row ['email'] );
		$this->assertEquals ( "Benjamin", $row ['firstname'] );
		$resp = $this->database->prepareAndFetchAll ( "select * from `user` where email= ? and firstname= ?", [ "[email protected]","Benjamin" ] );
		$row = current ( $resp );
		$this->assertEquals ( "[email protected]", $row ['email'] );
		$this->assertEquals ( "Benjamin", $row ['firstname'] );
	}

	/**
	 * Tests Database->prepareAndFetchAllColumn()
	 */
	public function testPrepareAndFetchAllColumn() {
		$this->beforeQuery ();
		$this->assertNotFalse ( $this->database->prepareAndFetchAllColumn ( "SELECT 1" ) );
		$this->assertNotFalse ( /** @scrutinizer ignore-type */ $this->database->prepareAndFetchAllColumn ( "SELECT 1" ) );
		$resp = $this->database->prepareAndFetchAllColumn ( "select * from `user`" );
		$this->assertEquals ( 101, sizeof ( $resp ) );
		$resp = $this->database->prepareAndFetchAllColumn ( "select email from `user` where email= ?", [ "[email protected]" ] );
		$row = current ( $resp );
		$row = current ( /** @scrutinizer ignore-type */ $resp );
		$this->assertEquals ( "[email protected]", $row );
		$resp = $this->database->prepareAndFetchAllColumn ( "select * from `user` where email= ? and firstname= ?", [ "[email protected]","Benjamin" ], 3 );
		$row = current ( $resp );
		$this->assertEquals ( "[email protected]", $row );
	}

	/**
	 * Tests Database->prepareAndFetchColumn()
	 */
	public function testPrepareAndFetchColumn() {
		$this->beforeQuery ();
		$result = $this->database->prepareAndFetchColumn ( "select email from `user` where email='[email protected]'" );
		$this->assertEquals ( '[email protected]', $result );
		$result = $this->database->prepareAndFetchColumn ( "select email from `user` limit 0,1" );
		$this->assertEquals ( '[email protected]', $result );
		$result = $this->database->prepareAndFetchColumn ( "select * from `user` limit 0,1", null, 3 );
		$this->assertEquals ( '[email protected]', $result );
		$result = $this->database->prepareAndFetchColumn ( "select * from `user` where `email`= ?", [ '[email protected]' ], 3 );
		$this->assertEquals ( '[email protected]', $result );
		$result = $this->database->prepareAndFetchColumn ( "select email from `user` where `email`= ?", [ '[email protected]' ] );
		$this->assertEquals ( '[email protected]', $result );
	}

	/**
	 * Tests Database->execute()
	 */
	public function testExecute() {
		$this->beforeQuery ();
		$this->assertEquals ( 0, $this->database->execute ( "DELETE FROM organization where 1=2" ) );
		$this->assertEquals ( 1, $this->database->execute ( "INSERT INTO organization(`name`,`domain`,`aliases`) VALUES('name','domain','aliases')" ) );
		$this->assertEquals ( 1, $this->database->execute ( "DELETE FROM organization where `name`='name'" ) );
	}

	/**
	 * Tests Database->setServerName()
	 */
	public function testSetServerName() {
		$this->assertEquals ( $this->db_server, $this->database->getServerName () );
		$this->database->setServerName ( 'localhost' );
		$this->assertEquals ( 'localhost', $this->database->getServerName () );
	}

	/**
	 * Tests Database->prepareStatement()
	 */
	public function testPrepareStatement() {
		$this->beforeQuery ();
		$st = $this->database->prepareStatement ( "SELECT 1" );
		$this->assertNotNull ( $st );
		$st = $this->database->prepareStatement ( "SELECT * from `user` limit 0,1" );
		$this->assertInstanceOf ( PDOStatement::class, $st );
	}

	/**
	 * Tests Database->bindValueFromStatement()
	 */
	public function testBindValueFromStatement() {
		$this->beforeQuery ();
		$st = $this->database->prepareStatement ( "SELECT * from `user` where email= :email limit 0,1" );
		$this->assertTrue ( $this->database->bindValueFromStatement ( $st, ':email', '[email protected]' ) );
	}

	/**
	 * Tests Database->lastInserId()
	 */
	public function testLastInserId() {
		$this->beforeQuery ();
		$this->assertEquals ( 1, $this->database->execute ( "INSERT INTO organization(`name`,`domain`,`aliases`) VALUES('name','domain','aliases')" ) );
		$id = $this->database->lastInserId ();
		$this->assertNotNull ( $id );
		$this->assertEquals ( 1, $this->database->execute ( "DELETE FROM organization where `id`=" . $id ) );
	}

	/**
	 * Tests Database->getTablesName()
	 */
	public function testGetTablesName() {
		$this->beforeQuery ();
		$tables = $this->database->getTablesName ();
		$this->assertEquals ( 7, sizeof ( $tables ) );
	}

	/**
	 * Tests Database->count()
	 */
	public function testCount() {
		$this->beforeQuery ();
		$this->assertEquals ( 101, $this->database->count ( "user" ) );
		$this->assertEquals ( 1, $this->database->count ( "user", "`email`='[email protected]'" ) );
		$this->assertEquals ( 0, $this->database->count ( "user", "1=2" ) );
		$this->assertEquals ( 101, $this->database->count ( "user", "1=1" ) );
	}

	/**
	 * Tests Database->queryColumn()
	 */
	public function testQueryColumn() {
		$this->beforeQuery ();
		$result = $this->database->queryColumn ( "select email from `user` where email='[email protected]'" );
		$this->assertEquals ( '[email protected]', $result );
		$result = $this->database->queryColumn ( "select email from `user` limit 0,1" );
		$this->assertEquals ( '[email protected]', $result );
		$result = $this->database->queryColumn ( "select * from `user` limit 0,1", 3 );
		$this->assertEquals ( '[email protected]', $result );
	}

	/**
	 * Tests Database->fetchAll()
	 */
	public function testFetchAll() {
		$this->beforeQuery ();
		$result = $this->database->fetchAll ( "select * from `user`" );
		$this->assertEquals ( 101, sizeof ( $result ) );
		$row = current ( $result );
		$this->assertEquals ( $row ['email'], '[email protected]' );
	}

	/**
	 * Tests Database->isConnected()
	 */
	public function testIsConnected() {
		$this->assertFalse ( $this->database->isConnected () );
		$this->assertFalse ( $this->database->ping () );
		$this->beforeQuery ();
		$this->assertTrue ( $this->database->isConnected () );
		$this->assertTrue ( $this->database->ping () );
	}

	/**
	 * Tests Database->setDbType()
	 */
	public function testSetDbType() {
		$this->assertEquals ( self::DB_TYPE, $this->database->getDbType () );
		$this->database->setDbType ( 'mongo' );
		$this->assertEquals ( 'mongo', $this->database->getDbType () );
	}

	/**
	 * Tests Database->ping()
	 */
	public function testPing() {
		$this->assertFalse ( $this->database->ping () );
		$this->beforeQuery ();
		$this->assertTrue ( $this->database->ping () );
	}

	/**
	 * Tests Database->getPdoObject()
	 */
	public function testGetPdoObject() {
		$this->assertNull ( $this->database->getPdoObject () );
		$this->beforeQuery ();
		$pdoo = $this->database->getPdoObject ();
		$this->assertNotNull ( $pdoo );
		$this->assertInstanceOf ( PDO::class, $pdoo );
	}

	/**
	 * Tests Database::getAvailableDrivers()
	 */
	public function testGetAvailableDrivers() {
		$drivers = Database::getAvailableDrivers ();
		$this->assertTrue ( sizeof ( $drivers ) > 0 );
	}
}


phpMv / ubiquity

Push — master ( 855968...4d0f3d )

DatabaseTest::testSetDbType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
