gian/phpmyadmin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #19010 from MauricioFauth/unit-tests

Browse Source 
Add some unit tests
This commit is contained in:
Maurício Meneghini Fauth 2024-02-24 19:32:18 -03:00 committed by GitHub
commit c30a9eec63
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 134 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
psalm-baseline.xml
View File

@ -15043,12 +15043,6 @@
<code><![CDATA[$_SESSION['userconfig']['ts']]]></code>
</MixedArrayAccess>
</file>
<file src="tests/unit/UserPrivilegesFactoryTest.php">
<DeprecatedMethod>
<code><![CDATA[Config::getInstance()]]></code>
<code><![CDATA[DatabaseInterface::getInstance()]]></code>
</DeprecatedMethod>
</file>
<file src="tests/unit/UtilTest.php">
<ArgumentTypeCoercion>
<code><![CDATA[$tz]]></code>

50
tests/unit/DatabaseInterfaceTest.php
View File

@ -4,6 +4,8 @@ declare(strict_types=1);
namespace PhpMyAdmin\Tests;
use PhpMyAdmin\Column;
use PhpMyAdmin\ColumnFull;
use PhpMyAdmin\Config;
use PhpMyAdmin\Config\Settings\Server;
use PhpMyAdmin\Current;
@ -12,6 +14,7 @@ use PhpMyAdmin\Dbal\ConnectionType;
use PhpMyAdmin\Dbal\DbiExtension;
use PhpMyAdmin\Dbal\ResultInterface;
use PhpMyAdmin\Dbal\Statement;
use PhpMyAdmin\Index;
use PhpMyAdmin\LanguageManager;
use PhpMyAdmin\Query\Utilities;
use PhpMyAdmin\SqlParser\Context;
@ -24,6 +27,8 @@ use ReflectionProperty;
use function array_keys;
#[CoversClass(DatabaseInterface::class)]
#[CoversClass(Column::class)]
#[CoversClass(ColumnFull::class)]
class DatabaseInterfaceTest extends AbstractTestCase
{
protected function setUp(): void
@ -792,4 +797,49 @@ class DatabaseInterfaceTest extends AbstractTestCase
yield 'null' => [null, 0];
yield 'false' => [false, 0];
}
public function testGetColumn(): void
{
(new ReflectionProperty(Index::class, 'registry'))->setValue(null, []);
$dbiDummy = $this->createDbiDummy();
$dbiDummy->removeDefaultResults();
$dbiDummy->addResult(
'SHOW COLUMNS FROM `test_db`.`test_table` LIKE \'test\\\\_column\'',
[['test_column', 'varchar(45)', 'NO', '', null, '']],
['Field', 'Type', 'Null', 'Key', 'Default', 'Extra'],
);
$dbiDummy->addResult('SHOW INDEXES FROM `test_db`.`test_table`', []);
$dbi = $this->createDatabaseInterface($dbiDummy);
$column = new Column('test_column', 'varchar(45)', false, '', null, '');
self::assertEquals($column, $dbi->getColumn('test_db', 'test_table', 'test_column'));
$dbiDummy->assertAllQueriesConsumed();
}
public function testGetColumnWithFullColumn(): void
{
(new ReflectionProperty(Index::class, 'registry'))->setValue(null, []);
$dbiDummy = $this->createDbiDummy();
$dbiDummy->removeDefaultResults();
$dbiDummy->addResult(
'SHOW FULL COLUMNS FROM `test_db`.`test_table` LIKE \'test\\\\_column\'',
// phpcs:ignore Generic.Files.LineLength.TooLong
[['test_column', 'varchar(45)', 'utf8mb4_general_ci', 'NO', '', null, '', 'select,insert,update,references', '']],
['Field', 'Type', 'Collation', 'Null', 'Key', 'Default', 'Extra', 'Privileges', 'Comment'],
);
$dbiDummy->addResult('SHOW INDEXES FROM `test_db`.`test_table`', []);
$dbi = $this->createDatabaseInterface($dbiDummy);
$column = new ColumnFull(
'test_column',
'varchar(45)',
'utf8mb4_general_ci',
false,
'',
null,
'',
'select,insert,update,references',
'',
);
self::assertEquals($column, $dbi->getColumn('test_db', 'test_table', 'test_column', true));
$dbiDummy->assertAllQueriesConsumed();
}
}

108
tests/unit/UserPrivilegesFactoryTest.php
View File

@ -4,42 +4,27 @@ declare(strict_types=1);
namespace PhpMyAdmin\Tests;
use PhpMyAdmin\Config;
use PhpMyAdmin\DatabaseInterface;
use PhpMyAdmin\ShowGrants;
use PhpMyAdmin\UserPrivileges;
use PhpMyAdmin\UserPrivilegesFactory;
use PhpMyAdmin\Utils\SessionCache;
use PHPUnit\Framework\Attributes\CoversClass;
#[CoversClass(UserPrivilegesFactory::class)]
#[CoversClass(UserPrivileges::class)]
#[CoversClass(ShowGrants::class)]
final class UserPrivilegesFactoryTest extends AbstractTestCase
{
private UserPrivilegesFactory $userPrivilegesFactory;
/**
* prepares environment for tests
*/
protected function setUp(): void
{
parent::setUp();
DatabaseInterface::$instance = $this->createDatabaseInterface();
Config::getInstance()->selectedServer['DisableIS'] = false;
$this->userPrivilegesFactory = new UserPrivilegesFactory(DatabaseInterface::getInstance());
}
/**
* Test for checkRequiredPrivilegesForAdjust
*/
public function testCheckRequiredPrivilegesForAdjust(): void
{
$userPrivilegesFactory = new UserPrivilegesFactory($this->createDatabaseInterface());
// TEST CASE 1
$userPrivileges = new UserPrivileges();
$showGrants = new ShowGrants('GRANT ALL PRIVILEGES ON *.* TO \'root\'@\'localhost\' WITH GRANT OPTION');
// call the to-be-tested function
$this->userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
$userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
self::assertTrue($userPrivileges->column);
self::assertTrue($userPrivileges->database);
@ -51,7 +36,7 @@ final class UserPrivilegesFactoryTest extends AbstractTestCase
$showGrants = new ShowGrants('GRANT ALL PRIVILEGES ON `mysql`.* TO \'root\'@\'localhost\' WITH GRANT OPTION');
// call the to-be-tested function
$this->userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
$userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
self::assertTrue($userPrivileges->column);
self::assertTrue($userPrivileges->database);
@ -63,7 +48,7 @@ final class UserPrivilegesFactoryTest extends AbstractTestCase
$showGrants = new ShowGrants('GRANT SELECT, INSERT, UPDATE, DELETE ON `mysql`.* TO \'root\'@\'localhost\'');
// call the to-be-tested function
$this->userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
$userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
self::assertTrue($userPrivileges->column);
self::assertTrue($userPrivileges->database);
@ -75,11 +60,86 @@ final class UserPrivilegesFactoryTest extends AbstractTestCase
$showGrants = new ShowGrants('GRANT SELECT, INSERT, UPDATE, DELETE ON `mysql`.`db` TO \'root\'@\'localhost\'');
// call the to-be-tested function
$this->userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
$userPrivilegesFactory->checkRequiredPrivilegesForAdjust($userPrivileges, $showGrants);
self::assertFalse($userPrivileges->column);
self::assertTrue($userPrivileges->database);
self::assertFalse($userPrivileges->routines);
self::assertFalse($userPrivileges->table);
}
public function testGetPrivilegesWithSkipGrantTables(): void
{
SessionCache::set('mysql_cur_user', '@');
$userPrivilegesFactory = new UserPrivilegesFactory($this->createDatabaseInterface());
$expected = new UserPrivileges(
database: true,
table: true,
column: true,
routines: true,
isReload: true,
isCreateDatabase: true,
);
self::assertEquals($expected, $userPrivilegesFactory->getPrivileges());
}
public function testGetPrivilegesFromSessionCache(): void
{
SessionCache::set('mysql_cur_user', 'test_user@localhost');
SessionCache::set('is_create_db_priv', true);
SessionCache::set('is_reload_priv', true);
SessionCache::set('db_to_create', 'databaseToCreate');
SessionCache::set('dbs_to_test', ['databasesToTest']);
SessionCache::set('proc_priv', true);
SessionCache::set('table_priv', true);
SessionCache::set('col_priv', true);
SessionCache::set('db_priv', true);
$userPrivilegesFactory = new UserPrivilegesFactory($this->createDatabaseInterface());
$expected = new UserPrivileges(true, true, true, true, true, true, 'databaseToCreate', ['databasesToTest']);
self::assertEquals($expected, $userPrivilegesFactory->getPrivileges());
}
public function testGetPrivilegesWithoutShowGrantsResult(): void
{
$dbiDummy = $this->createDbiDummy();
$dbiDummy->addResult('SHOW GRANTS', false);
SessionCache::set('mysql_cur_user', 'test_user@localhost');
$userPrivilegesFactory = new UserPrivilegesFactory($this->createDatabaseInterface($dbiDummy));
$expected = new UserPrivileges(databasesToTest: ['information_schema', 'performance_schema', 'mysql', 'sys']);
self::assertEquals($expected, $userPrivilegesFactory->getPrivileges());
$dbiDummy->assertAllQueriesConsumed();
}
public function testGetPrivilegesWithoutGrants(): void
{
$dbiDummy = $this->createDbiDummy();
$dbiDummy->addResult('SHOW GRANTS', []);
SessionCache::set('mysql_cur_user', 'test_user@localhost');
$userPrivilegesFactory = new UserPrivilegesFactory($this->createDatabaseInterface($dbiDummy));
$expected = new UserPrivileges(databasesToTest: ['information_schema', 'performance_schema', 'mysql', 'sys']);
self::assertEquals($expected, $userPrivilegesFactory->getPrivileges());
$dbiDummy->assertAllQueriesConsumed();
}
public function testGetPrivilegesWithAllPrivileges(): void
{
$dbiDummy = $this->createDbiDummy();
$dbiDummy->addResult(
'SHOW GRANTS',
[['GRANT ALL PRIVILEGES ON *.* TO \'test_user\'@\'localhost\' WITH GRANT OPTION']],
);
SessionCache::set('mysql_cur_user', 'test_user@localhost');
$userPrivilegesFactory = new UserPrivilegesFactory($this->createDatabaseInterface($dbiDummy));
$expected = new UserPrivileges(true, true, true, true, true, true);
self::assertEquals($expected, $userPrivilegesFactory->getPrivileges());
$dbiDummy->assertAllQueriesConsumed();
}
}