DatabaseTest::testSetCache() - Code Metrics - Inspection of "Update unit tests" - AdamB7586/pdo-dbal - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 62965a...dba830 )

by Adam

created 2018-02-15 16:37 UTC

DatabaseTest::testSetCache() A

↳ Parent: DatabaseTest

Complexity

Conditions	4
Paths	6

Size

Total Lines	20
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
rs	9.2
c	0
b	0
f	0
cc	4
eloc	16
nc	6
nop	0

<?php
namespace DBAL\Tests;

use PHPUnit\Framework\TestCase;
use DBAL\Database;
use DBAL\Caching\RedisCache;

class DatabaseTest extends TestCase{
    public $db;
    
    protected $test_table = 'test_table';
    
    /**
     * @covers \DBAL\Database::__construct
     * @covers \DBAL\Database::connectToServer
     * @covers \DBAL\Database::isConnected
     */
    public function setUp(){
        $this->connectToLiveDB();
        if(!$this->db->isConnected()){
            $this->markTestSkipped(
                'No local database connection is available'
            );
        }
        else{
            $this->db->query("DROP TABLE IF EXISTS `{$this->test_table}`;");
            $this->db->query("CREATE TABLE `{$this->test_table}` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(255) NOT NULL,
    `text_field` text NOT NULL,
    `number_field` int(11) NOT NULL,
    PRIMARY KEY (`id`)
);");
            $this->db->insert($this->test_table, array('name' => 'My Name', 'text_field' => 'Hello World', 'number_field' => 256));
            $this->db->insert($this->test_table, array('name' => 'Inigo Montoya', 'text_field' => 'You killed my father, prepare to die', 'number_field' => 320));
        }
    }
    
    /**
     * @covers \DBAL\Database::__destruct
     * @covers \DBAL\Database::closeDatabase
     */
    public function tearDown(){
        $this->db = null;
    }
    
    /**
     * @covers \DBAL\Database::connectToServer
     * @covers \DBAL\Database::isConnected
     */
    public function testConnect(){
        $this->assertTrue($this->db->isConnected());
    }
    
    /**
     * @covers \DBAL\Database::__destruct
     * @covers \DBAL\Database::closeDatabase
     */
    public function testCloseDatabaseConnection(){
        $this->assertTrue($this->db->isConnected());
        $this->assertObjectHasAttribute('sql', $this->db);
        $this->db = null;
        $this->assertNull($this->db);
        $this->connectToLiveDB();
    }
    
    /**
     * @covers \DBAL\Database::__construct
     * @covers \DBAL\Database::connectToServer
     * @covers \DBAL\Database::isConnected
     * @covers \DBAL\Database::error
     */
    public function testConnectFailure(){
        $db = new Database('localhost', 'wrong_username', 'incorrect_password', 'non_existent_db');
        $this->assertFalse($db->isConnected());
        $this->connectToLiveDB();
    }
    
    /**
     * @covers \DBAL\Database::query
     */
    public function testQuery(){
        // Insert a couple of test vales
        $this->db->insert($this->test_table, array('name' => 'My Name', 'text_field' => 'Hello World', 'number_field' => rand(1, 1000)));
        $this->db->insert($this->test_table, array('name' => 'Inigo Montoya', 'text_field' => 'You killed my father, prepare to die', 'number_field' => rand(1, 1000)));
        $query = $this->db->query("SELECT * FROM `test_table` WHERE `id` = ?", array(1));
        $this->assertArrayHasKey(0, $query);
        $this->assertCount(1, $query);
    }
    
    /**
     * @covers \DBAL\Database::select
     * @covers \DBAL\Database::selectAll
     * @covers \DBAL\Database::buildSelectQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::orderBy
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testSelect(){
       $simpleSelect = $this->db->select($this->test_table, array('id' => array('>', 1)), '*', array('id' => 'ASC'));
       $this->assertArrayHasKey('name', $simpleSelect);
       $this->assertFalse($this->db->select($this->test_table, array('id' => 'IS NULL'), '*', array('id' => 'ASC')));
       $this->assertArrayHasKey('name', $this->db->select($this->test_table, array('id' => 'IS NOT NULL'), array('id', 'name'), array('id' => 'ASC')));
       $between = $this->db->select($this->test_table, array('id' => array('BETWEEN' => array(2, 3))), '*', array('id' => 'ASC'));
       $this->assertEquals(2, $between['id']);
    }
    
    /**
     * @covers \DBAL\Database::selectAll
     * @covers \DBAL\Database::buildSelectQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::rowCount
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::limit
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testSelectAll(){
        $selectAll = $this->db->selectAll($this->test_table);
        $this->assertGreaterThan(1, $this->db->numRows());
        $this->assertArrayHasKey('id', $selectAll[0]);
        $this->db->selectAll($this->test_table, array(), '*', array(), 1);
        $this->assertEquals(1, $this->db->rowCount());
        for($i = 1; $i <= 200; $i++){
            // Insert some more values for testing
            $this->db->insert($this->test_table, array('name' => 'Name '.$i, 'text_field' => 'TextField'.$i, 'number_field' => rand(1, 1000)));
        }
        $original = $this->db->selectAll($this->test_table, array(), '*', array(), array(0 => 50));
        $this->assertLessThan(51, $this->db->numRows());
        $random = $this->db->selectAll($this->test_table, array(), '*', 'RAND()', array(0 => 50));
        $this->assertNotEquals($original, $random);
    }
    
    /**
     * @covers \DBAL\Database::selectAll
     * @covers \DBAL\Database::buildSelectQuery
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Database::error
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testSelectFailure(){
        $this->assertFalse($this->db->selectAll($this->test_table, array('id' => 100)));
        $this->assertFalse($this->db->selectAll('unknown_table'));
    }
    
    /**
     * @covers \DBAL\Database::fetchColumn
     * @covers \DBAL\Database::buildSelectQuery
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testFetchColumn(){
        $this->assertEquals('Inigo Montoya', $this->db->fetchColumn($this->test_table, array('id' => 2), '*', 1));
    }
    
    /**
     * @covers \DBAL\Database::fetchColumn
     * @covers \DBAL\Database::buildSelectQuery
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testFetchColumnFailure(){
        $this->assertFalse($this->db->fetchColumn($this->test_table, array('id' => 2), '*', 6));
    }


    /**
     * @covers \DBAL\Database::insert
     * @covers \DBAL\Database::fields
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::bindValues
     */
    public function testInsert(){
        $this->assertTrue($this->db->insert($this->test_table, array('name' => 'Third User', 'text_field' => 'Helloooooo', 'number_field' => rand(1, 1000))));
    }
    
    /**
     * @covers \DBAL\Database::insert
     * @covers \DBAL\Database::fields
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Database::error
     */
    public function testInsertFailure(){
        $this->assertFalse($this->db->insert($this->test_table, array('id' => 3, 'name' => 'Third User', 'text_field' => NULL, 'number_field' => rand(1, 1000))));
    }
    
    /**
     * @covers \DBAL\Database::update
     * @covers \DBAL\Database::fields
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testUpdate(){
        $this->assertTrue($this->db->update($this->test_table, array('text_field' => 'Altered text', 'number_field' => rand(1, 1000)), array('id' => 1)));
    }
    
    /**
     * @covers \DBAL\Database::update
     * @covers \DBAL\Database::fields
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Database::error
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testUpdateFailure(){
        $this->assertFalse($this->db->update($this->test_table, array('number_field' => 256), array('id' => 1)));
    }
    
    /**
     * @covers \DBAL\Database::delete
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testDelete(){
        $this->assertTrue($this->db->delete($this->test_table, array('id' => array('>=', 2))));
    }
    
    /**
     * @covers \DBAL\Database::delete
     * @covers \DBAL\Database::where
     * @covers \DBAL\Database::formatValues
     * @covers \DBAL\Database::numRows
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Modifiers\Operators::getOperatorFormat
     * @covers \DBAL\Modifiers\Operators::isOperatorValid
     * @covers \DBAL\Modifiers\Operators::isOperatorPrepared
     * @covers \DBAL\Modifiers\SafeString::makeSafe
     */
    public function testDeleteFailure(){
        $this->assertFalse($this->db->delete($this->test_table, array('id' => 3)));
    }
    
    /**
     * @covers \DBAL\Database::count
     * @covers \DBAL\Database::executeQuery
     */    
    public function testCount(){
        $this->assertEquals(2, $this->db->count($this->test_table));
    }
    
    /**
     * @covers \DBAL\Database::lastInsertID
     */
    public function testLastInsertID(){
        $this->testInsert();
        $this->assertEquals(3, $this->db->lastInsertID());
    }
    
    /**
     * @covers \DBAL\Database::serverVersion
     */
    public function testServerVersion(){
        $this->assertGreaterThan(5, $this->db->serverVersion());
        $this->assertContains('.', $this->db->serverVersion());
    }
    
    /**
     * @covers \DBAL\Database::setCaching
     */
    public function testSetCaching(){
        if (extension_loaded('redis')) {
            $caching = new RedisCache();
            $caching->connect('127.0.0.1', 6379);
            $this->db->setCaching($caching);
        }
        $this->assertObjectHasAttribute('sql', $this->db->setCaching('not_a_instance_od_cache_but_should_still_return'));
    }
    
    /**
     * @covers \DBAL\Database::truncate
     * @covers \DBAL\Database::error
     * @covers \DBAL\Database::executeQuery
     * @covers \DBAL\Database::bindValues
     * @covers \DBAL\Database::numRows
     */
    public function testTruncate(){
        $this->db->truncate($this->test_table);
        $this->assertEquals(0, $this->db->count($this->test_table));
        $this->assertFalse($this->db->truncate('any_table'));
    }
    
    /**
     * @covers \DBAL\Database::setLogLocation
     */
    public function testChangeLogLocation(){
        $this->assertObjectHasAttribute('sql', $this->db->setLogLocation('test/logs/'));
        $this->assertObjectHasAttribute('sql', $this->db->setLogLocation(1));
        $this->assertObjectHasAttribute('sql', $this->db->setLogLocation(false));
    }
    
    /**
     * @covers \DBAL\Database::setCache
     * @covers \DBAL\Database::getCache
     */
    public function testSetCache(){
        $loaded = false;
        if (extension_loaded('redis')) {
            $caching = new RedisCache();
            $caching->connect('127.0.0.1', 6379);
            $this->db->setCaching($caching);
            $this->db->setCache('cache_status', 'Success');
            $loaded = ($this->db->getCache('cache_status') === 'Success' ? true : false);
        }
        if($loaded === true) {
            $this->assertEmpty($this->db->setCache('mykey', 'Hello'));
            $this->assertEquals('Hello', $this->db->getCache('mykey'));
            $this->assertEmpty($this->db->getCache('another_key_name'));
        }
        else{
            $this->assertEmpty($this->db->setCache('mykey', 'Hello'));
            $this->assertFalse($this->db->getCache('mykey'));
            $this->assertFalse($this->db->getCache('another_key_name'));
        }
    }
    
    protected function connectToLiveDB(){
        $this->db = new Database($GLOBALS['HOSTNAME'], $GLOBALS['USERNAME'], $GLOBALS['PASSWORD'], $GLOBALS['DATABASE'], '127.0.0.1', false, true, $GLOBALS['DRIVER']);
    }
}


1			<?php
2			namespace DBAL\Tests;
3
4			use PHPUnit\Framework\TestCase;
5			use DBAL\Database;
6			use DBAL\Caching\RedisCache;
7
8			class DatabaseTest extends TestCase{
9			public $db;
10
11			protected $test_table = 'test_table';
12
13			/**
14			* @covers \DBAL\Database::__construct
15			* @covers \DBAL\Database::connectToServer
16			* @covers \DBAL\Database::isConnected
17			*/
18			public function setUp(){
19			$this->connectToLiveDB();
20			if(!$this->db->isConnected()){
21			$this->markTestSkipped(
22			'No local database connection is available'
23			);
24			}
25			else{
26			$this->db->query("DROP TABLE IF EXISTS `{$this->test_table}`;");
27			$this->db->query("CREATE TABLE `{$this->test_table}` (
28			`id` int(11) NOT NULL AUTO_INCREMENT,
29			`name` varchar(255) NOT NULL,
30			`text_field` text NOT NULL,
31			`number_field` int(11) NOT NULL,
32			PRIMARY KEY (`id`)
33			);");
34			$this->db->insert($this->test_table, array('name' => 'My Name', 'text_field' => 'Hello World', 'number_field' => 256));
35			$this->db->insert($this->test_table, array('name' => 'Inigo Montoya', 'text_field' => 'You killed my father, prepare to die', 'number_field' => 320));
36			}
37			}
38
39			/**
40			* @covers \DBAL\Database::__destruct
41			* @covers \DBAL\Database::closeDatabase
42			*/
43			public function tearDown(){
44			$this->db = null;
45			}
46
47			/**
48			* @covers \DBAL\Database::connectToServer
49			* @covers \DBAL\Database::isConnected
50			*/
51			public function testConnect(){
52			$this->assertTrue($this->db->isConnected());
53			}
54
55			/**
56			* @covers \DBAL\Database::__destruct
57			* @covers \DBAL\Database::closeDatabase
58			*/
59			public function testCloseDatabaseConnection(){
60			$this->assertTrue($this->db->isConnected());
61			$this->assertObjectHasAttribute('sql', $this->db);
62			$this->db = null;
63			$this->assertNull($this->db);
64			$this->connectToLiveDB();
65			}
66
67			/**
68			* @covers \DBAL\Database::__construct
69			* @covers \DBAL\Database::connectToServer
70			* @covers \DBAL\Database::isConnected
71			* @covers \DBAL\Database::error
72			*/
73			public function testConnectFailure(){
74			$db = new Database('localhost', 'wrong_username', 'incorrect_password', 'non_existent_db');
75			$this->assertFalse($db->isConnected());
76			$this->connectToLiveDB();
77			}
78
79			/**
80			* @covers \DBAL\Database::query
81			*/
82			public function testQuery(){
83			// Insert a couple of test vales
84			$this->db->insert($this->test_table, array('name' => 'My Name', 'text_field' => 'Hello World', 'number_field' => rand(1, 1000)));
85			$this->db->insert($this->test_table, array('name' => 'Inigo Montoya', 'text_field' => 'You killed my father, prepare to die', 'number_field' => rand(1, 1000)));
86			$query = $this->db->query("SELECT * FROM `test_table` WHERE `id` = ?", array(1));
87			$this->assertArrayHasKey(0, $query);
88			$this->assertCount(1, $query);
89			}
90
91			/**
92			* @covers \DBAL\Database::select
93			* @covers \DBAL\Database::selectAll
94			* @covers \DBAL\Database::buildSelectQuery
95			* @covers \DBAL\Database::where
96			* @covers \DBAL\Database::orderBy
97			* @covers \DBAL\Database::formatValues
98			* @covers \DBAL\Database::executeQuery
99			* @covers \DBAL\Database::bindValues
100			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
101			* @covers \DBAL\Modifiers\Operators::isOperatorValid
102			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
103			* @covers \DBAL\Modifiers\SafeString::makeSafe
104			*/
105			public function testSelect(){
106			$simpleSelect = $this->db->select($this->test_table, array('id' => array('>', 1)), '*', array('id' => 'ASC'));
107			$this->assertArrayHasKey('name', $simpleSelect);
108			$this->assertFalse($this->db->select($this->test_table, array('id' => 'IS NULL'), '*', array('id' => 'ASC')));
109			$this->assertArrayHasKey('name', $this->db->select($this->test_table, array('id' => 'IS NOT NULL'), array('id', 'name'), array('id' => 'ASC')));
110			$between = $this->db->select($this->test_table, array('id' => array('BETWEEN' => array(2, 3))), '*', array('id' => 'ASC'));
111			$this->assertEquals(2, $between['id']);
112			}
113
114			/**
115			* @covers \DBAL\Database::selectAll
116			* @covers \DBAL\Database::buildSelectQuery
117			* @covers \DBAL\Database::where
118			* @covers \DBAL\Database::numRows
119			* @covers \DBAL\Database::rowCount
120			* @covers \DBAL\Database::formatValues
121			* @covers \DBAL\Database::limit
122			* @covers \DBAL\Database::executeQuery
123			* @covers \DBAL\Database::bindValues
124			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
125			* @covers \DBAL\Modifiers\Operators::isOperatorValid
126			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
127			* @covers \DBAL\Modifiers\SafeString::makeSafe
128			*/
129			public function testSelectAll(){
130			$selectAll = $this->db->selectAll($this->test_table);
131			$this->assertGreaterThan(1, $this->db->numRows());
132			$this->assertArrayHasKey('id', $selectAll[0]);
133			$this->db->selectAll($this->test_table, array(), '*', array(), 1);
134			$this->assertEquals(1, $this->db->rowCount());
135			for($i = 1; $i <= 200; $i++){
136			// Insert some more values for testing
137			$this->db->insert($this->test_table, array('name' => 'Name '.$i, 'text_field' => 'TextField'.$i, 'number_field' => rand(1, 1000)));
138			}
139			$original = $this->db->selectAll($this->test_table, array(), '*', array(), array(0 => 50));
140			$this->assertLessThan(51, $this->db->numRows());
141			$random = $this->db->selectAll($this->test_table, array(), '*', 'RAND()', array(0 => 50));
142			$this->assertNotEquals($original, $random);
143			}
144
145			/**
146			* @covers \DBAL\Database::selectAll
147			* @covers \DBAL\Database::buildSelectQuery
148			* @covers \DBAL\Database::executeQuery
149			* @covers \DBAL\Database::where
150			* @covers \DBAL\Database::formatValues
151			* @covers \DBAL\Database::bindValues
152			* @covers \DBAL\Database::error
153			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
154			* @covers \DBAL\Modifiers\Operators::isOperatorValid
155			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
156			* @covers \DBAL\Modifiers\SafeString::makeSafe
157			*/
158			public function testSelectFailure(){
159			$this->assertFalse($this->db->selectAll($this->test_table, array('id' => 100)));
160			$this->assertFalse($this->db->selectAll('unknown_table'));
161			}
162
163			/**
164			* @covers \DBAL\Database::fetchColumn
165			* @covers \DBAL\Database::buildSelectQuery
166			* @covers \DBAL\Database::executeQuery
167			* @covers \DBAL\Database::where
168			* @covers \DBAL\Database::formatValues
169			* @covers \DBAL\Database::bindValues
170			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
171			* @covers \DBAL\Modifiers\Operators::isOperatorValid
172			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
173			* @covers \DBAL\Modifiers\SafeString::makeSafe
174			*/
175			public function testFetchColumn(){
176			$this->assertEquals('Inigo Montoya', $this->db->fetchColumn($this->test_table, array('id' => 2), '*', 1));
177			}
178
179			/**
180			* @covers \DBAL\Database::fetchColumn
181			* @covers \DBAL\Database::buildSelectQuery
182			* @covers \DBAL\Database::executeQuery
183			* @covers \DBAL\Database::where
184			* @covers \DBAL\Database::formatValues
185			* @covers \DBAL\Database::bindValues
186			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
187			* @covers \DBAL\Modifiers\Operators::isOperatorValid
188			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
189			* @covers \DBAL\Modifiers\SafeString::makeSafe
190			*/
191			public function testFetchColumnFailure(){
192			$this->assertFalse($this->db->fetchColumn($this->test_table, array('id' => 2), '*', 6));
193			}
194
195
196			/**
197			* @covers \DBAL\Database::insert
198			* @covers \DBAL\Database::fields
199			* @covers \DBAL\Database::numRows
200			* @covers \DBAL\Database::executeQuery
201			* @covers \DBAL\Database::bindValues
202			*/
203			public function testInsert(){
204			$this->assertTrue($this->db->insert($this->test_table, array('name' => 'Third User', 'text_field' => 'Helloooooo', 'number_field' => rand(1, 1000))));
205			}
206
207			/**
208			* @covers \DBAL\Database::insert
209			* @covers \DBAL\Database::fields
210			* @covers \DBAL\Database::numRows
211			* @covers \DBAL\Database::executeQuery
212			* @covers \DBAL\Database::bindValues
213			* @covers \DBAL\Database::error
214			*/
215			public function testInsertFailure(){
216			$this->assertFalse($this->db->insert($this->test_table, array('id' => 3, 'name' => 'Third User', 'text_field' => NULL, 'number_field' => rand(1, 1000))));
217			}
218
219			/**
220			* @covers \DBAL\Database::update
221			* @covers \DBAL\Database::fields
222			* @covers \DBAL\Database::numRows
223			* @covers \DBAL\Database::executeQuery
224			* @covers \DBAL\Database::where
225			* @covers \DBAL\Database::formatValues
226			* @covers \DBAL\Database::bindValues
227			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
228			* @covers \DBAL\Modifiers\Operators::isOperatorValid
229			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
230			* @covers \DBAL\Modifiers\SafeString::makeSafe
231			*/
232			public function testUpdate(){
233			$this->assertTrue($this->db->update($this->test_table, array('text_field' => 'Altered text', 'number_field' => rand(1, 1000)), array('id' => 1)));
234			}
235
236			/**
237			* @covers \DBAL\Database::update
238			* @covers \DBAL\Database::fields
239			* @covers \DBAL\Database::numRows
240			* @covers \DBAL\Database::executeQuery
241			* @covers \DBAL\Database::where
242			* @covers \DBAL\Database::formatValues
243			* @covers \DBAL\Database::bindValues
244			* @covers \DBAL\Database::error
245			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
246			* @covers \DBAL\Modifiers\Operators::isOperatorValid
247			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
248			* @covers \DBAL\Modifiers\SafeString::makeSafe
249			*/
250			public function testUpdateFailure(){
251			$this->assertFalse($this->db->update($this->test_table, array('number_field' => 256), array('id' => 1)));
252			}
253
254			/**
255			* @covers \DBAL\Database::delete
256			* @covers \DBAL\Database::numRows
257			* @covers \DBAL\Database::formatValues
258			* @covers \DBAL\Database::executeQuery
259			* @covers \DBAL\Database::where
260			* @covers \DBAL\Database::bindValues
261			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
262			* @covers \DBAL\Modifiers\Operators::isOperatorValid
263			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
264			* @covers \DBAL\Modifiers\SafeString::makeSafe
265			*/
266			public function testDelete(){
267			$this->assertTrue($this->db->delete($this->test_table, array('id' => array('>=', 2))));
268			}
269
270			/**
271			* @covers \DBAL\Database::delete
272			* @covers \DBAL\Database::where
273			* @covers \DBAL\Database::formatValues
274			* @covers \DBAL\Database::numRows
275			* @covers \DBAL\Database::executeQuery
276			* @covers \DBAL\Database::bindValues
277			* @covers \DBAL\Modifiers\Operators::getOperatorFormat
278			* @covers \DBAL\Modifiers\Operators::isOperatorValid
279			* @covers \DBAL\Modifiers\Operators::isOperatorPrepared
280			* @covers \DBAL\Modifiers\SafeString::makeSafe
281			*/
282			public function testDeleteFailure(){
283			$this->assertFalse($this->db->delete($this->test_table, array('id' => 3)));
284			}
285
286			/**
287			* @covers \DBAL\Database::count
288			* @covers \DBAL\Database::executeQuery
289			*/
290			public function testCount(){
291			$this->assertEquals(2, $this->db->count($this->test_table));
292			}
293
294			/**
295			* @covers \DBAL\Database::lastInsertID
296			*/
297			public function testLastInsertID(){
298			$this->testInsert();
299			$this->assertEquals(3, $this->db->lastInsertID());
300			}
301
302			/**
303			* @covers \DBAL\Database::serverVersion
304			*/
305			public function testServerVersion(){
306			$this->assertGreaterThan(5, $this->db->serverVersion());
307			$this->assertContains('.', $this->db->serverVersion());
308			}
309
310			/**
311			* @covers \DBAL\Database::setCaching
312			*/
313			public function testSetCaching(){
314			if (extension_loaded('redis')) {
315			$caching = new RedisCache();
316			$caching->connect('127.0.0.1', 6379);
317			$this->db->setCaching($caching);
318			}
319			$this->assertObjectHasAttribute('sql', $this->db->setCaching('not_a_instance_od_cache_but_should_still_return'));
320			}
321
322			/**
323			* @covers \DBAL\Database::truncate
324			* @covers \DBAL\Database::error
325			* @covers \DBAL\Database::executeQuery
326			* @covers \DBAL\Database::bindValues
327			* @covers \DBAL\Database::numRows
328			*/
329			public function testTruncate(){
330			$this->db->truncate($this->test_table);
331			$this->assertEquals(0, $this->db->count($this->test_table));
332			$this->assertFalse($this->db->truncate('any_table'));
333			}
334
335			/**
336			* @covers \DBAL\Database::setLogLocation
337			*/
338			public function testChangeLogLocation(){
339			$this->assertObjectHasAttribute('sql', $this->db->setLogLocation('test/logs/'));
340			$this->assertObjectHasAttribute('sql', $this->db->setLogLocation(1));
341			$this->assertObjectHasAttribute('sql', $this->db->setLogLocation(false));
342			}
343
344			/**
345			* @covers \DBAL\Database::setCache
346			* @covers \DBAL\Database::getCache
347			*/
348			public function testSetCache(){
349			$loaded = false;
350			if (extension_loaded('redis')) {
351			$caching = new RedisCache();
352			$caching->connect('127.0.0.1', 6379);
353			$this->db->setCaching($caching);
354			$this->db->setCache('cache_status', 'Success');
355			$loaded = ($this->db->getCache('cache_status') === 'Success' ? true : false);
356			}
357			if($loaded === true) {
358			$this->assertEmpty($this->db->setCache('mykey', 'Hello'));
359			$this->assertEquals('Hello', $this->db->getCache('mykey'));
360			$this->assertEmpty($this->db->getCache('another_key_name'));
361			}
362			else{
363			$this->assertEmpty($this->db->setCache('mykey', 'Hello'));
364			$this->assertFalse($this->db->getCache('mykey'));
365			$this->assertFalse($this->db->getCache('another_key_name'));
366			}
367			}
368
369			protected function connectToLiveDB(){
370			$this->db = new Database($GLOBALS['HOSTNAME'], $GLOBALS['USERNAME'], $GLOBALS['PASSWORD'], $GLOBALS['DATABASE'], '127.0.0.1', false, true, $GLOBALS['DRIVER']);
371			}
372			}
373

AdamB7586 / pdo-dbal

Push — master ( 62965a...dba830 )

DatabaseTest::testSetCache() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like