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

Remove method AbstractTestCase::callFunction()

Browse Source 
Signed-off-by: Maurício Meneghini Fauth <mauricio@mfauth.net>
This commit is contained in:
Maurício Meneghini Fauth 2026-02-20 19:20:53 -03:00
parent 8a9e4c4085
commit b93e747994
No known key found for this signature in database
GPG Key ID: 6A16FD38AFC89CC8
25 changed files with 299 additions and 734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
phpstan-baseline.neon
View File

@ -15282,12 +15282,6 @@ parameters:
count: 1
path: tests/unit/Database/CentralColumnsTest.php
-
message: '#^Parameter \#1 \$needle of static method PHPUnit\\Framework\\Assert\:\:assertStringContainsString\(\) expects string, mixed given\.$#'
identifier: argument.type
count: 1
path: tests/unit/Database/CentralColumnsTest.php
-
message: '''
#^Call to deprecated method getInstance\(\) of class PhpMyAdmin\\Dbal\\DatabaseInterface\:
@ -15465,7 +15459,7 @@ parameters:
-
message: '#^Parameter \#2 \$haystack of static method PHPUnit\\Framework\\Assert\:\:assertStringContainsString\(\) expects string, mixed given\.$#'
identifier: argument.type
count: 4
count: 2
path: tests/unit/Display/ResultsTest.php
-

30
psalm-baseline.xml
View File

@ -9757,14 +9757,6 @@
<DeprecatedMethod>
<code><![CDATA[Config::getInstance()]]></code>
</DeprecatedMethod>
<MixedArgument>
<code><![CDATA[$this->callFunction(
$this->centralColumns,
CentralColumns::class,
'getHtmlForEditTableRow',
[self::MODIFIED_COLUMN_DATA[0], 0],
)]]></code>
</MixedArgument>
</file>
<file src="tests/unit/Database/DesignerTest.php">
<DeprecatedMethod>
@ -9848,28 +9840,6 @@
<MixedArgument>
<code><![CDATA[$output]]></code>
<code><![CDATA[$output]]></code>
<code><![CDATA[$this->callFunction(
$this->object,
DisplayResults::class,
'getDataCellForNonNumericColumns',
[
$column,
$class,
$meta,
$map,
$urlParams,
$conditionField,
$transformationPlugin,
$transformOptions,
$statementInfo,
],
)]]></code>
<code><![CDATA[$this->callFunction(
$this->object,
DisplayResults::class,
'handleNonPrintableContents',
[$category, $content, $transformationPlugin, $transformOptions, $meta, $urlParams, &$isTruncated],
)]]></code>
</MixedArgument>
<MixedArrayAccess>
<code><![CDATA[$_SESSION['tmpval']['pftext']]]></code>

20
tests/unit/AbstractTestCase.php
View File

@ -21,7 +21,6 @@ use PhpMyAdmin\Template;
use PhpMyAdmin\Tests\Stubs\DbiDummy;
use PhpMyAdmin\Tracking\Tracker;
use PHPUnit\Framework\TestCase;
use ReflectionClass;
use ReflectionProperty;
/**
@ -104,23 +103,4 @@ abstract class AbstractTestCase extends TestCase
$languageManager->activate($languageEn);
Translator::load();
}
/**
* Call protected functions by setting visibility to public.
*
* @param object|null $object The object to inspect, pass null for static objects()
* @param string $className The class name
* @param string $methodName The method name
* @param mixed[] $params The parameters for the invocation
* @phpstan-param class-string $className
*
* @return mixed the output from the protected method.
*/
protected function callFunction(object|null $object, string $className, string $methodName, array $params): mixed
{
$class = new ReflectionClass($className);
$method = $class->getMethod($methodName);
return $method->invokeArgs($object, $params);
}
}

41
tests/unit/BrowseForeignersTest.php
View File

@ -10,6 +10,7 @@ use PhpMyAdmin\ConfigStorage\ForeignData;
use PhpMyAdmin\Template;
use PhpMyAdmin\Theme\ThemeManager;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionMethod;
#[CoversClass(BrowseForeigners::class)]
class BrowseForeignersTest extends AbstractTestCase
@ -70,33 +71,21 @@ class BrowseForeignersTest extends AbstractTestCase
$foreignData = new ForeignData(false, 5, '', null, '');
self::assertSame(
'',
$this->callFunction(
$this->browseForeigners,
BrowseForeigners::class,
'getHtmlForGotoPage',
[$foreignData, 0],
),
(new ReflectionMethod(BrowseForeigners::class, 'getHtmlForGotoPage'))
->invokeArgs($this->browseForeigners, [$foreignData, 0]),
);
$foreignData = new ForeignData(false, 5, '', [], '');
self::assertSame(
'',
$this->callFunction(
$this->browseForeigners,
BrowseForeigners::class,
'getHtmlForGotoPage',
[$foreignData, 15],
),
(new ReflectionMethod(BrowseForeigners::class, 'getHtmlForGotoPage'))
->invokeArgs($this->browseForeigners, [$foreignData, 15]),
);
$foreignData = new ForeignData(false, 30, '', [], '');
$result = $this->callFunction(
$this->browseForeigners,
BrowseForeigners::class,
'getHtmlForGotoPage',
[$foreignData, 15],
);
$result = (new ReflectionMethod(BrowseForeigners::class, 'getHtmlForGotoPage'))
->invokeArgs($this->browseForeigners, [$foreignData, 15]);
self::assertStringStartsWith('Page number:', $result);
@ -118,12 +107,8 @@ class BrowseForeignersTest extends AbstractTestCase
self::assertSame(
['foobar<baz', ''],
$this->callFunction(
$this->browseForeigners,
BrowseForeigners::class,
'getDescriptionAndTitle',
[$desc],
),
(new ReflectionMethod(BrowseForeigners::class, 'getDescriptionAndTitle'))
->invokeArgs($this->browseForeigners, [$desc]),
);
$config = new Config();
@ -132,12 +117,8 @@ class BrowseForeignersTest extends AbstractTestCase
self::assertSame(
['fooba...', 'foobar<baz'],
$this->callFunction(
$browseForeigners,
BrowseForeigners::class,
'getDescriptionAndTitle',
[$desc],
),
(new ReflectionMethod(BrowseForeigners::class, 'getDescriptionAndTitle'))
->invokeArgs($browseForeigners, [$desc]),
);
}

16
tests/unit/Command/SetVersionCommandTest.php
View File

@ -9,6 +9,7 @@ use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use RangeException;
use ReflectionMethod;
use Symfony\Component\Console\Command\Command;
use function class_exists;
@ -60,12 +61,7 @@ class SetVersionCommandTest extends AbstractTestCase
$this->expectException(RangeException::class);
$this->expectExceptionMessage('The version number is in the wrong format: ' . $version);
$this->callFunction(
$this->command,
SetVersionCommand::class,
'getGeneratedClass',
[$version],
);
(new ReflectionMethod(SetVersionCommand::class, 'getGeneratedClass'))->invokeArgs($this->command, [$version]);
}
/** @return mixed[][] */
@ -170,12 +166,8 @@ class SetVersionCommandTest extends AbstractTestCase
self::markTestSkipped('The Symfony Console is missing');
}
$output = $this->callFunction(
$this->command,
SetVersionCommand::class,
'getGeneratedClass',
[$version],
);
$output = (new ReflectionMethod(SetVersionCommand::class, 'getGeneratedClass'))
->invokeArgs($this->command, [$version]);
$template = <<<'PHP'
<?php

17
tests/unit/Command/TwigLintCommandTest.php
View File

@ -8,6 +8,7 @@ use PhpMyAdmin\Command\TwigLintCommand;
use PhpMyAdmin\Config;
use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionMethod;
use Symfony\Component\Console\Command\Command;
use Twig\Error\SyntaxError;
@ -39,7 +40,7 @@ class TwigLintCommandTest extends AbstractTestCase
public function testGetTemplateContents(): void
{
$contents = $this->callFunction($this->command, TwigLintCommand::class, 'getTemplateContents', [
$contents = (new ReflectionMethod(TwigLintCommand::class, 'getTemplateContents'))->invokeArgs($this->command, [
__DIR__ . '/../_data/file_listing/subfolder/one.ini',
]);
@ -49,7 +50,7 @@ class TwigLintCommandTest extends AbstractTestCase
public function testFindFiles(): void
{
$path = __DIR__ . '/../_data/file_listing';
$filesFound = $this->callFunction($this->command, TwigLintCommand::class, 'findFiles', [$path]);
$filesFound = (new ReflectionMethod(TwigLintCommand::class, 'findFiles'))->invokeArgs($this->command, [$path]);
// Sort results to avoid file system test specific failures
sort($filesFound, SORT_NATURAL);
@ -65,7 +66,8 @@ class TwigLintCommandTest extends AbstractTestCase
public function testGetFilesInfo(): void
{
$path = __DIR__ . '/../_data/file_listing';
$filesInfos = $this->callFunction($this->command, TwigLintCommand::class, 'getFilesInfo', [$path]);
$filesInfos = (new ReflectionMethod(TwigLintCommand::class, 'getFilesInfo'))
->invokeArgs($this->command, [$path]);
// Sort results to avoid file system test specific failures
sort($filesInfos, SORT_REGULAR);
@ -107,15 +109,18 @@ class TwigLintCommandTest extends AbstractTestCase
public function testGetContext(): void
{
$context = $this->callFunction($this->command, TwigLintCommand::class, 'getContext', ['{{ file }', 0]);
$context = (new ReflectionMethod(TwigLintCommand::class, 'getContext'))
->invokeArgs($this->command, ['{{ file }', 0]);
self::assertSame([1 => '{{ file }'], $context);
$context = $this->callFunction($this->command, TwigLintCommand::class, 'getContext', ['{{ file }', 3]);
$context = (new ReflectionMethod(TwigLintCommand::class, 'getContext'))
->invokeArgs($this->command, ['{{ file }', 3]);
self::assertSame([1 => '{{ file }'], $context);
$context = $this->callFunction($this->command, TwigLintCommand::class, 'getContext', ['{{ file }', 5]);
$context = (new ReflectionMethod(TwigLintCommand::class, 'getContext'))
->invokeArgs($this->command, ['{{ file }', 5]);
self::assertSame([], $context);
}

14
tests/unit/Command/WriteGitRevisionCommandTest.php
View File

@ -7,6 +7,7 @@ namespace PhpMyAdmin\Tests\Command;
use PhpMyAdmin\Command\WriteGitRevisionCommand;
use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionMethod;
use Symfony\Component\Console\Command\Command;
use function class_exists;
@ -59,15 +60,10 @@ class WriteGitRevisionCommandTest extends AbstractTestCase
],
);
$output = $this->callFunction(
$command,
WriteGitRevisionCommand::class,
'getRevisionInfo',
[
'https://github.com/phpmyadmin/phpmyadmin/commit/%s',
'https://github.com/phpmyadmin/phpmyadmin/tree/%s',
],
);
$output = (new ReflectionMethod(WriteGitRevisionCommand::class, 'getRevisionInfo'))->invokeArgs($command, [
'https://github.com/phpmyadmin/phpmyadmin/commit/%s',
'https://github.com/phpmyadmin/phpmyadmin/tree/%s',
]);
$template = <<<'PHP'
<?php

33
tests/unit/Controllers/Database/StructureControllerTest.php
View File

@ -21,6 +21,7 @@ use PhpMyAdmin\Tracking\TrackingChecker;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
#[CoversClass(StructureController::class)]
class StructureControllerTest extends AbstractTestCase
@ -338,31 +339,19 @@ class StructureControllerTest extends AbstractTestCase
self::assertSame(
[[], '', '', 0],
$this->callFunction(
$structureController,
StructureController::class,
'getValuesForMroongaTable',
[[], 0],
),
(new ReflectionMethod(StructureController::class, 'getValuesForMroongaTable'))
->invokeArgs($structureController, [[], 0]),
);
// Enable stats
$config->settings['ShowStats'] = true;
$this->callFunction(
$structureController,
StructureController::class,
'getDatabaseInfo',
[self::createStub(ServerRequest::class)],
);
(new ReflectionMethod(StructureController::class, 'getDatabaseInfo'))
->invokeArgs($structureController, [self::createStub(ServerRequest::class)]);
self::assertSame(
[['Data_length' => 45, 'Index_length' => 60], '105', 'B', 105],
$this->callFunction(
$structureController,
StructureController::class,
'getValuesForMroongaTable',
[['Data_length' => 45, 'Index_length' => 60], 0],
),
(new ReflectionMethod(StructureController::class, 'getValuesForMroongaTable'))
->invokeArgs($structureController, [['Data_length' => 45, 'Index_length' => 60], 0]),
);
self::assertSame(
@ -372,12 +361,8 @@ class StructureControllerTest extends AbstractTestCase
'B',
180, //105 + 75
],
$this->callFunction(
$structureController,
StructureController::class,
'getValuesForMroongaTable',
[['Data_length' => 45, 'Index_length' => 60], 75],
),
(new ReflectionMethod(StructureController::class, 'getValuesForMroongaTable'))
->invokeArgs($structureController, [['Data_length' => 45, 'Index_length' => 60], 75]),
);
}

13
tests/unit/Controllers/GisDataEditorControllerTest.php
View File

@ -14,6 +14,7 @@ use PhpMyAdmin\Tests\Stubs\ResponseRenderer;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use ReflectionMethod;
#[CoversClass(GisDataEditorController::class)]
class GisDataEditorControllerTest extends AbstractTestCase
@ -37,16 +38,8 @@ class GisDataEditorControllerTest extends AbstractTestCase
public function testValidateGisData(mixed $gisData, string $type, string|null $value, string $expected): void
{
/** @var string $gisData */
$gisData = $this->callFunction(
$this->controller,
GisDataEditorController::class,
'extractGisType',
[
$gisData,
$type,
$value,
],
);
$gisData = (new ReflectionMethod(GisDataEditorController::class, 'extractGisType'))
->invokeArgs($this->controller, [$gisData, $type, $value]);
self::assertSame($expected, $gisData);
}

6
tests/unit/Controllers/Import/SimulateDmlControllerTest.php
View File

@ -18,6 +18,7 @@ use PhpMyAdmin\Tests\Stubs\ResponseRenderer;
use PhpMyAdmin\Url;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use ReflectionMethod;
use ReflectionProperty;
use function count;
@ -50,10 +51,11 @@ final class SimulateDmlControllerTest extends AbstractTestCase
$controller = new SimulateDmlController(new ResponseRenderer(), new SimulateDml($dbi));
/** @var Parser $parser */
$parser = $this->callFunction($controller, SimulateDmlController::class, 'createParser', [$sqlQuery, ';']);
$parser = (new ReflectionMethod(SimulateDmlController::class, 'createParser'))
->invokeArgs($controller, [$sqlQuery, ';']);
self::assertCount(count($expectedPerQuery), $parser->statements);
$this->callFunction($controller, SimulateDmlController::class, 'process', [$parser]);
(new ReflectionMethod(SimulateDmlController::class, 'process'))->invokeArgs($controller, [$parser]);
$dummyDbi->assertAllSelectsConsumed();
$dummyDbi->assertAllQueriesConsumed();

57
tests/unit/Controllers/Server/VariablesControllerTest.php
View File

@ -20,6 +20,7 @@ use PhpMyAdmin\Tests\Stubs\DummyResult;
use PhpMyAdmin\Tests\Stubs\ResponseRenderer as ResponseStub;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\MockObject\MockObject;
use ReflectionMethod;
use ReflectionProperty;
use function __;
@ -137,35 +138,23 @@ class VariablesControllerTest extends AbstractTestCase
$response = new ReflectionProperty(ServerVariablesProvider::class, 'instance');
$response->setValue(null, $voidProviderMock);
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('<abbr title="3">3 B</abbr>', $formattedValue);
self::assertTrue($isHtmlFormatted);
//name is_numeric and the value type is not byte
$args = [$nameForValueNotByte, '3'];
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('3', $formattedValue);
self::assertFalse($isHtmlFormatted);
//value is not a number
$args = [$nameForValueNotByte, 'value'];
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('value', $formattedValue);
self::assertFalse($isHtmlFormatted);
}
@ -194,35 +183,23 @@ class VariablesControllerTest extends AbstractTestCase
//name is_numeric and the value type is byte
$args = [$nameForValueByte, '3'];
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('<abbr title="3">3 B</abbr>', $formattedValue);
self::assertTrue($isHtmlFormatted);
//name is_numeric and the value type is not byte
$args = [$nameForValueNotByte, '3'];
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('3', $formattedValue);
self::assertFalse($isHtmlFormatted);
//value is not a number
$args = [$nameForValueNotByte, 'value'];
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('value', $formattedValue);
self::assertFalse($isHtmlFormatted);
}
@ -246,12 +223,8 @@ class VariablesControllerTest extends AbstractTestCase
//name is_numeric and the value type is byte
$args = [$nameForValueByte, '3'];
[$formattedValue, $isHtmlFormatted] = $this->callFunction(
$controller,
VariablesController::class,
'formatVariable',
$args,
);
[$formattedValue, $isHtmlFormatted] = ((new ReflectionMethod(VariablesController::class, 'formatVariable'))
->invokeArgs($controller, $args));
self::assertSame('3', $formattedValue);
self::assertFalse($isHtmlFormatted);

17
tests/unit/Controllers/Table/ReplaceControllerTest.php
View File

@ -28,6 +28,7 @@ use PhpMyAdmin\Tests\Stubs\ResponseRenderer;
use PhpMyAdmin\Transformations;
use PhpMyAdmin\UrlParams;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionMethod;
use ReflectionProperty;
#[CoversClass(ReplaceController::class)]
@ -176,12 +177,8 @@ class ReplaceControllerTest extends AbstractTestCase
);
/** @var array $result */
$result = $this->callFunction(
$replaceController,
ReplaceController::class,
'getParamsForUpdateOrInsert',
[$request1],
);
$result = (new ReflectionMethod(ReplaceController::class, 'getParamsForUpdateOrInsert'))
->invokeArgs($replaceController, [$request1]);
self::assertSame(
[['LIMIT 1'], true, true],
@ -195,12 +192,8 @@ class ReplaceControllerTest extends AbstractTestCase
]);
/** @var array $result */
$result = $this->callFunction(
$replaceController,
ReplaceController::class,
'getParamsForUpdateOrInsert',
[$request2],
);
$result = (new ReflectionMethod(ReplaceController::class, 'getParamsForUpdateOrInsert'))
->invokeArgs($replaceController, [$request2]);
self::assertSame(
[['a', 'c'], false, true],

22
tests/unit/Database/CentralColumnsTest.php
View File

@ -20,6 +20,7 @@ use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\PreserveGlobalState;
use PHPUnit\Framework\Attributes\RunTestsInSeparateProcesses;
use PHPUnit\Framework\MockObject\MockObject;
use ReflectionMethod;
use ReflectionProperty;
use function array_slice;
@ -309,15 +310,10 @@ class CentralColumnsTest extends AbstractTestCase
'phpmyadmin',
);
self::assertStringContainsString(
$this->callFunction(
$this->centralColumns,
CentralColumns::class,
'getHtmlForEditTableRow',
[self::MODIFIED_COLUMN_DATA[0], 0],
),
$result,
);
$actual = (new ReflectionMethod(CentralColumns::class, 'getHtmlForEditTableRow'))
->invokeArgs($this->centralColumns, [self::MODIFIED_COLUMN_DATA[0], 0]);
self::assertIsString($actual);
self::assertStringContainsString($actual, $result);
}
/**
@ -377,12 +373,8 @@ class CentralColumnsTest extends AbstractTestCase
->willReturn(array_slice(self::COLUMN_DATA, 1, 1));
self::assertSame(
array_slice(self::MODIFIED_COLUMN_DATA, 1, 1),
$this->callFunction(
$this->centralColumns,
CentralColumns::class,
'findExistingColumns',
['phpmyadmin', ['col1']],
),
(new ReflectionMethod(CentralColumns::class, 'findExistingColumns'))
->invokeArgs($this->centralColumns, ['phpmyadmin', ['col1']]),
);
}

15
tests/unit/Database/SearchTest.php
View File

@ -14,6 +14,7 @@ use PhpMyAdmin\Template;
use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use ReflectionMethod;
#[CoversClass(Search::class)]
class SearchTest extends AbstractTestCase
@ -74,12 +75,7 @@ class SearchTest extends AbstractTestCase
$this->object->setSearchParams($request);
self::assertSame(
$expected,
$this->callFunction(
$this->object,
Search::class,
'getWhereClause',
['table1'],
),
(new ReflectionMethod(Search::class, 'getWhereClause'))->invokeArgs($this->object, ['table1']),
);
}
@ -188,12 +184,7 @@ class SearchTest extends AbstractTestCase
'select_count' => 'SELECT COUNT(*) AS `count` FROM `pma`.`table1` WHERE FALSE',
'delete' => 'DELETE FROM `pma`.`table1` WHERE FALSE',
],
$this->callFunction(
$this->object,
Search::class,
'getSearchSqls',
['table1'],
),
(new ReflectionMethod(Search::class, 'getSearchSqls'))->invokeArgs($this->object, ['table1']),
);
}

243
tests/unit/Display/ResultsTest.php
View File

@ -34,6 +34,7 @@ use PhpMyAdmin\Tests\Stubs\DbiDummy;
use PhpMyAdmin\Transformations;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use ReflectionMethod;
use ReflectionProperty;
use stdClass;
@ -91,12 +92,8 @@ class ResultsTest extends AbstractTestCase
public function testisSelect(): void
{
self::assertTrue(
$this->callFunction(
$this->object,
DisplayResults::class,
'isSelect',
[Query::getAll('SELECT * FROM pma')],
),
(new ReflectionMethod(DisplayResults::class, 'isSelect'))
->invokeArgs($this->object, [Query::getAll('SELECT * FROM pma')]),
);
}
@ -104,12 +101,8 @@ class ResultsTest extends AbstractTestCase
{
self::assertSame(
'datetimefield',
$this->callFunction(
$this->object,
DisplayResults::class,
'getClassForDateTimeRelatedFields',
[FieldHelper::fromArray(['type' => MYSQLI_TYPE_TIMESTAMP])],
),
(new ReflectionMethod(DisplayResults::class, 'getClassForDateTimeRelatedFields'))
->invokeArgs($this->object, [FieldHelper::fromArray(['type' => MYSQLI_TYPE_TIMESTAMP])]),
);
}
@ -117,12 +110,8 @@ class ResultsTest extends AbstractTestCase
{
self::assertSame(
'datefield',
$this->callFunction(
$this->object,
DisplayResults::class,
'getClassForDateTimeRelatedFields',
[FieldHelper::fromArray(['type' => MYSQLI_TYPE_DATE])],
),
(new ReflectionMethod(DisplayResults::class, 'getClassForDateTimeRelatedFields'))
->invokeArgs($this->object, [FieldHelper::fromArray(['type' => MYSQLI_TYPE_DATE])]),
);
}
@ -130,12 +119,8 @@ class ResultsTest extends AbstractTestCase
{
self::assertSame(
'text',
$this->callFunction(
$this->object,
DisplayResults::class,
'getClassForDateTimeRelatedFields',
[FieldHelper::fromArray(['type' => MYSQLI_TYPE_STRING])],
),
(new ReflectionMethod(DisplayResults::class, 'getClassForDateTimeRelatedFields'))
->invokeArgs($this->object, [FieldHelper::fromArray(['type' => MYSQLI_TYPE_STRING])]),
);
}
@ -147,12 +132,7 @@ class ResultsTest extends AbstractTestCase
$_SESSION['tmpval']['max_rows'] = DisplayResults::ALL_ROWS;
self::assertSame(
[0, 0],
$this->callFunction(
$this->object,
DisplayResults::class,
'getOffsets',
[],
),
(new ReflectionMethod(DisplayResults::class, 'getOffsets'))->invokeArgs($this->object, []),
);
}
@ -165,12 +145,7 @@ class ResultsTest extends AbstractTestCase
$_SESSION['tmpval']['pos'] = 4;
self::assertSame(
[9, 0],
$this->callFunction(
$this->object,
DisplayResults::class,
'getOffsets',
[],
),
(new ReflectionMethod(DisplayResults::class, 'getOffsets'))->invokeArgs($this->object, []),
);
}
@ -248,12 +223,8 @@ class ResultsTest extends AbstractTestCase
self::assertSame(
$output,
$this->callFunction(
$this->object,
DisplayResults::class,
'getSpecialLinkUrl',
[$specialSchemaLinks[$db][$table][$fieldName], $columnValue, $rowInfo],
),
(new ReflectionMethod(DisplayResults::class, 'getSpecialLinkUrl'))
->invokeArgs($this->object, [$specialSchemaLinks[$db][$table][$fieldName], $columnValue, $rowInfo]),
);
}
@ -299,24 +270,16 @@ class ResultsTest extends AbstractTestCase
self::assertEquals(
$output,
$this->callFunction(
$this->object,
DisplayResults::class,
'getRowInfoForSpecialLinks',
[$row],
),
(new ReflectionMethod(DisplayResults::class, 'getRowInfoForSpecialLinks'))
->invokeArgs($this->object, [$row]),
);
}
public function testSetHighlightedColumnGlobalField(): void
{
$query = 'SELECT * FROM db_name WHERE `db_name`.`tbl`.id > 0 AND `id` < 10';
$this->callFunction(
$this->object,
DisplayResults::class,
'setHighlightedColumnGlobalField',
[Query::getAll($query)],
);
(new ReflectionMethod(DisplayResults::class, 'setHighlightedColumnGlobalField'))
->invokeArgs($this->object, [Query::getAll($query)]);
self::assertSame([
'db_name' => true,
@ -355,12 +318,7 @@ class ResultsTest extends AbstractTestCase
Config::getInstance()->set('LimitChars', $limitChars);
self::assertSame(
$output,
$this->callFunction(
$this->object,
DisplayResults::class,
'getPartialText',
[$str],
),
(new ReflectionMethod(DisplayResults::class, 'getPartialText'))->invokeArgs($this->object, [$str]),
);
}
@ -431,15 +389,12 @@ class ResultsTest extends AbstractTestCase
): void {
$_SESSION['tmpval']['display_binary'] = $displayBinary;
$_SESSION['tmpval']['display_blob'] = $displayBlob;
self::assertStringContainsString(
$output,
$this->callFunction(
$this->object,
DisplayResults::class,
'handleNonPrintableContents',
[$category, $content, $transformationPlugin, $transformOptions, $meta, $urlParams, &$isTruncated],
),
$actual = (new ReflectionMethod(DisplayResults::class, 'handleNonPrintableContents'))->invokeArgs(
$this->object,
[$category, $content, $transformationPlugin, $transformOptions, $meta, $urlParams, &$isTruncated],
);
self::assertIsString($actual);
self::assertStringContainsString($output, $actual);
}
/**
@ -605,25 +560,22 @@ class ResultsTest extends AbstractTestCase
$config = Config::getInstance();
$config->set('ProtectBinary', $protectBinary);
$statementInfo = new StatementInfo(new Parser(), null, new StatementFlags(), [], []);
self::assertStringContainsString(
$output,
$this->callFunction(
$this->object,
DisplayResults::class,
'getDataCellForNonNumericColumns',
[
$column,
$class,
$meta,
$map,
$urlParams,
$conditionField,
$transformationPlugin,
$transformOptions,
$statementInfo,
],
),
$actual = (new ReflectionMethod(DisplayResults::class, 'getDataCellForNonNumericColumns'))->invokeArgs(
$this->object,
[
$column,
$class,
$meta,
$map,
$urlParams,
$conditionField,
$transformationPlugin,
$transformOptions,
$statementInfo,
],
);
self::assertIsString($actual);
self::assertStringContainsString($output, $actual);
}
/**
@ -691,21 +643,16 @@ class ResultsTest extends AbstractTestCase
);
// Actually invoke tested method
$output = $this->callFunction(
$this->object,
DisplayResults::class,
'getRowValues',
[
['3600', 'true'],
0,
false,
[],
'disabled',
false,
$query,
Query::getAll($query),
],
);
$output = (new ReflectionMethod(DisplayResults::class, 'getRowValues'))->invokeArgs($this->object, [
['3600', 'true'],
0,
false,
[],
'disabled',
false,
$query,
Query::getAll($query),
]);
// Dateformat
self::assertStringContainsString('Jan 01, 1970 at 01:00 AM', $output);
@ -786,12 +733,8 @@ class ResultsTest extends AbstractTestCase
string $colName,
string $urlParamsRemove,
): void {
$output = $this->callFunction(
$this->object,
DisplayResults::class,
'getSortOrderHiddenInputs',
[$urlParams, $colName],
);
$output = (new ReflectionMethod(DisplayResults::class, 'getSortOrderHiddenInputs'))
->invokeArgs($this->object, [$urlParams, $colName]);
$out = urldecode(htmlspecialchars_decode($output));
self::assertStringContainsString(
'name="url-remove-order" value="index.php?route=/sql&sql_query=' . $sqlRemove,
@ -823,30 +766,17 @@ class ResultsTest extends AbstractTestCase
/** @see https://github.com/phpmyadmin/phpmyadmin/issues/16836 */
public function testBuildValueDisplayNoTrainlingSpaces(): void
{
$output = $this->callFunction(
$this->object,
DisplayResults::class,
'buildValueDisplay',
['my_class', false, ' special value '],
);
$output = (new ReflectionMethod(DisplayResults::class, 'buildValueDisplay'))
->invokeArgs($this->object, ['my_class', false, ' special value ']);
self::assertSame('<td class="text-start my_class"> special value </td>' . "\n", $output);
$output = $this->callFunction(
$this->object,
DisplayResults::class,
'buildValueDisplay',
['my_class', false, '0x11e6ac0cfb1e8bf3bf48b827ebdafb0b'],
);
$output = (new ReflectionMethod(DisplayResults::class, 'buildValueDisplay'))
->invokeArgs($this->object, ['my_class', false, '0x11e6ac0cfb1e8bf3bf48b827ebdafb0b']);
self::assertSame('<td class="text-start my_class">0x11e6ac0cfb1e8bf3bf48b827ebdafb0b</td>' . "\n", $output);
$output = $this->callFunction(
$this->object,
DisplayResults::class,
'buildValueDisplay',
[
'my_class',
true,// condition mode
'0x11e6ac0cfb1e8bf3bf48b827ebdafb0b',
],
);
$output = (new ReflectionMethod(DisplayResults::class, 'buildValueDisplay'))->invokeArgs($this->object, [
'my_class',
true,// condition mode
'0x11e6ac0cfb1e8bf3bf48b827ebdafb0b',
]);
self::assertSame(
'<td class="text-start my_class condition">0x11e6ac0cfb1e8bf3bf48b827ebdafb0b</td>' . "\n",
$output,
@ -1745,17 +1675,12 @@ class ResultsTest extends AbstractTestCase
): void {
Config::getInstance()->set('Order', $orderSetting);
$data = $this->callFunction(
$this->object,
DisplayResults::class,
'getSingleAndMultiSortUrls',
[
[new SortExpression('Country', 'Code', 'ASC', '`Country`.`Code`')],
'Country',
'FoundedIn',
FieldHelper::fromArray(['type' => $metaType]),
],
);
$data = (new ReflectionMethod(DisplayResults::class, 'getSingleAndMultiSortUrls'))->invokeArgs($this->object, [
[new SortExpression('Country', 'Code', 'ASC', '`Country`.`Code`')],
'Country',
'FoundedIn',
FieldHelper::fromArray(['type' => $metaType]),
]);
self::assertSame([
'ORDER BY `Country`.`FoundedIn` ' . $querySortDirection, // singleSortOrder
@ -1763,17 +1688,12 @@ class ResultsTest extends AbstractTestCase
'', // orderImg
], $data);
$data = $this->callFunction(
$this->object,
DisplayResults::class,
'getSingleAndMultiSortUrls',
[
[new SortExpression('Country', 'Code', 'ASC', '`Country`.`Code`')],
'Country',
'Code2',
FieldHelper::fromArray(['type' => $metaType]),
],
);
$data = (new ReflectionMethod(DisplayResults::class, 'getSingleAndMultiSortUrls'))->invokeArgs($this->object, [
[new SortExpression('Country', 'Code', 'ASC', '`Country`.`Code`')],
'Country',
'Code2',
FieldHelper::fromArray(['type' => $metaType]),
]);
self::assertSame([
'ORDER BY `Country`.`Code2` ' . $querySortDirection, // singleSortOrder
@ -1781,21 +1701,16 @@ class ResultsTest extends AbstractTestCase
'', // orderImg
], $data);
$data = $this->callFunction(
$this->object,
DisplayResults::class,
'getSingleAndMultiSortUrls',
$data = (new ReflectionMethod(DisplayResults::class, 'getSingleAndMultiSortUrls'))->invokeArgs($this->object, [
[
[
new SortExpression('Country', 'Continent', 'DESC', '`Country`.`Continent`'),
new SortExpression('Country', 'Region', 'ASC', '`Country`.`Region`'),
new SortExpression('Country', 'Population', 'ASC', '`Country`.`Population`'),
],
'Country',
'Code2',
FieldHelper::fromArray(['type' => $metaType]),
new SortExpression('Country', 'Continent', 'DESC', '`Country`.`Continent`'),
new SortExpression('Country', 'Region', 'ASC', '`Country`.`Region`'),
new SortExpression('Country', 'Population', 'ASC', '`Country`.`Population`'),
],
);
'Country',
'Code2',
FieldHelper::fromArray(['type' => $metaType]),
]);
self::assertSame([
'ORDER BY `Country`.`Code2` ' . $querySortDirection, // singleSortOrder

8
tests/unit/Error/ErrorHandlerTest.php
View File

@ -15,6 +15,7 @@ use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Medium;
use ReflectionMethod;
use Throwable;
use function array_keys;
@ -105,12 +106,7 @@ class ErrorHandlerTest extends AbstractTestCase
*/
public function testCheckSavedErrors(): void
{
$this->callFunction(
$this->object,
ErrorHandler::class,
'checkSavedErrors',
[],
);
(new ReflectionMethod(ErrorHandler::class, 'checkSavedErrors'))->invokeArgs($this->object, []);
self::assertArrayNotHasKey('errors', $_SESSION);
}

8
tests/unit/Error/ErrorReportTest.php
View File

@ -18,6 +18,7 @@ use PhpMyAdmin\Utils\UserAgentParser;
use PhpMyAdmin\Version;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use ReflectionMethod;
use function htmlspecialchars;
use function json_encode;
@ -328,12 +329,7 @@ class ErrorReportTest extends AbstractTestCase
// $this->errorReport->sanitizeUrl
self::assertSame(
$result,
$this->callFunction(
$this->errorReport,
ErrorReport::class,
'sanitizeUrl',
[$url],
),
(new ReflectionMethod(ErrorReport::class, 'sanitizeUrl'))->invokeArgs($this->errorReport, [$url]),
);
}
}

3
tests/unit/FooterTest.php
View File

@ -12,6 +12,7 @@ use PhpMyAdmin\Footer;
use PhpMyAdmin\Template;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\Medium;
use ReflectionMethod;
use function json_encode;
@ -77,7 +78,7 @@ class FooterTest extends AbstractTestCase
$object->childIterator = new ArrayIterator();
$object->child->parent = $object;
$this->callFunction($this->object, Footer::class, 'removeRecursion', [&$object]);
(new ReflectionMethod(Footer::class, 'removeRecursion'))->invokeArgs($this->object, [&$object]);
self::assertSame(
'{"child":{"parent":"***RECURSION***"},"childIterator":"***ITERATOR***"}',
json_encode($object),

25
tests/unit/Gis/GisGeometryTest.php
View File

@ -11,6 +11,7 @@ use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\MockObject\MockObject;
use ReflectionMethod;
#[CoversClass(GisGeometry::class)]
class GisGeometryTest extends AbstractTestCase
@ -48,12 +49,8 @@ class GisGeometryTest extends AbstractTestCase
#[DataProvider('providerForTestGetCoordinatesExtent')]
public function testGetCoordinatesExtent(string $pointSet, Extent $expected): void
{
$extent = $this->callFunction(
$this->object,
GisGeometry::class,
'getCoordinatesExtent',
[$pointSet],
);
$extent = (new ReflectionMethod(GisGeometry::class, 'getCoordinatesExtent'))
->invokeArgs($this->object, [$pointSet]);
self::assertEquals($expected, $extent);
}
@ -87,12 +84,8 @@ class GisGeometryTest extends AbstractTestCase
{
self::assertSame(
$output,
$this->callFunction(
$this->object,
GisGeometry::class,
'parseWktAndSrid',
[$value],
),
(new ReflectionMethod(GisGeometry::class, 'parseWktAndSrid'))
->invokeArgs($this->object, [$value]),
);
}
@ -131,12 +124,8 @@ class GisGeometryTest extends AbstractTestCase
bool $linear,
array $output,
): void {
$points = $this->callFunction(
$this->object,
GisGeometry::class,
'extractPointsInternal',
[$pointSet, $scaleData, $linear],
);
$points = (new ReflectionMethod(GisGeometry::class, 'extractPointsInternal'))
->invokeArgs($this->object, [$pointSet, $scaleData, $linear]);
self::assertEquals($output, $points);
}

100
tests/unit/Gis/GisVisualizationTest.php
View File

@ -10,6 +10,7 @@ use PhpMyAdmin\Gis\GisVisualization;
use PhpMyAdmin\Gis\GisVisualizationSettings;
use PhpMyAdmin\Tests\AbstractTestCase;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionMethod;
use ReflectionProperty;
#[CoversClass(GisVisualization::class)]
@ -34,33 +35,23 @@ class GisVisualizationTest extends AbstractTestCase
$this->dbi->setVersion(['@@version' => '5.5.0']);
$gis = GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc'));
$dataSet = $this->callFunction(
$gis,
GisVisualization::class,
'scaleDataSet',
$dataSet = (new ReflectionMethod(GisVisualization::class, 'scaleDataSet'))->invokeArgs($gis, [
[
[
['abc' => null],// The column is nullable
['abc' => 2],// Some impossible test case
],
['abc' => null],// The column is nullable
['abc' => 2],// Some impossible test case
],
);
]);
self::assertNull($dataSet);
$dataSet = $this->callFunction(
$gis,
GisVisualization::class,
'scaleDataSet',
$dataSet = (new ReflectionMethod(GisVisualization::class, 'scaleDataSet'))->invokeArgs($gis, [
[
[
['abc' => null],// The column is nullable
['abc' => 2],// Some impossible test case
['abc' => 'MULTILINESTRING((36 140,47 233,62 75),(36 100,17 233,178 93))'],
['abc' => 'POINT(100 250)'],
['abc' => 'MULTIPOINT(125 50,156 250,178 143,175 80)'],
],
['abc' => null],// The column is nullable
['abc' => 2],// Some impossible test case
['abc' => 'MULTILINESTRING((36 140,47 233,62 75),(36 100,17 233,178 93))'],
['abc' => 'POINT(100 250)'],
['abc' => 'MULTIPOINT(125 50,156 250,178 143,175 80)'],
],
);
]);
self::assertEquals(
new ScaleData(
offsetX: -45.35714285714286,
@ -72,17 +63,12 @@ class GisVisualizationTest extends AbstractTestCase
);
// Regression test for bug with 0.0 sentinel values
$dataSet = $this->callFunction(
$gis,
GisVisualization::class,
'scaleDataSet',
$dataSet = (new ReflectionMethod(GisVisualization::class, 'scaleDataSet'))->invokeArgs($gis, [
[
[
['abc' => 'MULTIPOLYGON(((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1)))'],
['abc' => 'MULTIPOLYGON(((10 10,10 13,13 13,13 10,10 10),(11 11,11 12,12 12,12 11,11 11)))'],
],
['abc' => 'MULTIPOLYGON(((0 0,0 3,3 3,3 0,0 0),(1 1,1 2,2 2,2 1,1 1)))'],
['abc' => 'MULTIPOLYGON(((10 10,10 13,13 13,13 10,10 10),(11 11,11 12,12 12,12 11,11 11)))'],
],
);
]);
self::assertEquals(
new ScaleData(
scale: 32.30769230769231,
@ -100,12 +86,8 @@ class GisVisualizationTest extends AbstractTestCase
public function testModifyQueryOld(): void
{
$this->dbi->setVersion(['@@version' => '5.5.0']);
$queryString = $this->callFunction(
GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')),
GisVisualization::class,
'modifySqlQuery',
[''],
);
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))
->invokeArgs(GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')), ['']);
self::assertSame('SELECT ASTEXT(`abc`) AS `abc`, SRID(`abc`) AS `srid` FROM () AS `temp_gis`', $queryString);
}
@ -116,12 +98,8 @@ class GisVisualizationTest extends AbstractTestCase
public function testModifyQuery(): void
{
$this->dbi->setVersion(['@@version' => '8.0.0']);
$queryString = $this->callFunction(
GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')),
GisVisualization::class,
'modifySqlQuery',
[''],
);
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))
->invokeArgs(GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')), ['']);
self::assertSame(
'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis`',
@ -135,10 +113,8 @@ class GisVisualizationTest extends AbstractTestCase
public function testModifyQueryTrimSqlEnd(): void
{
$this->dbi->setVersion(['@@version' => '8.0.0']);
$queryString = $this->callFunction(
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))->invokeArgs(
GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')),
GisVisualization::class,
'modifySqlQuery',
['SELECT 1 FROM foo;'],
);
@ -154,10 +130,8 @@ class GisVisualizationTest extends AbstractTestCase
public function testModifyQueryLabelColumn(): void
{
$this->dbi->setVersion(['@@version' => '8.0.0']);
$queryString = $this->callFunction(
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))->invokeArgs(
GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'country_geom', 'country name')),
GisVisualization::class,
'modifySqlQuery',
[''],
);
@ -176,12 +150,7 @@ class GisVisualizationTest extends AbstractTestCase
$this->dbi->setVersion(['@@version' => '8.0.0']);
$gis = GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc'));
(new ReflectionProperty(GisVisualization::class, 'rows'))->setValue($gis, 10);
$queryString = $this->callFunction(
$gis,
GisVisualization::class,
'modifySqlQuery',
[''],
);
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))->invokeArgs($gis, ['']);
self::assertSame(
'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis` LIMIT 10',
@ -191,12 +160,7 @@ class GisVisualizationTest extends AbstractTestCase
$gis = GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc'));
(new ReflectionProperty(GisVisualization::class, 'pos'))->setValue($gis, 10);
(new ReflectionProperty(GisVisualization::class, 'rows'))->setValue($gis, 15);
$queryString = $this->callFunction(
$gis,
GisVisualization::class,
'modifySqlQuery',
[''],
);
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))->invokeArgs($gis, ['']);
self::assertSame(
'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis` LIMIT 10, 15',
@ -210,12 +174,8 @@ class GisVisualizationTest extends AbstractTestCase
public function testModifyQueryVersion8(): void
{
$this->dbi->setVersion(['@@version' => '8.0.1']);
$queryString = $this->callFunction(
GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')),
GisVisualization::class,
'modifySqlQuery',
[''],
);
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))
->invokeArgs(GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')), ['']);
self::assertSame(
'SELECT ST_ASTEXT(`abc`, \'axis-order=long-lat\') AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis`',
@ -229,12 +189,8 @@ class GisVisualizationTest extends AbstractTestCase
public function testModifyQueryMariaDB(): void
{
$this->dbi->setVersion(['@@version' => '8.0.0-MariaDB']);
$queryString = $this->callFunction(
GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')),
GisVisualization::class,
'modifySqlQuery',
[''],
);
$queryString = (new ReflectionMethod(GisVisualization::class, 'modifySqlQuery'))
->invokeArgs(GisVisualization::getByData([], new GisVisualizationSettings(600, 450, 'abc')), ['']);
self::assertSame(
'SELECT ST_ASTEXT(`abc`) AS `abc`, ST_SRID(`abc`) AS `srid` FROM () AS `temp_gis`',

222
tests/unit/InsertEditTest.php
View File

@ -28,6 +28,7 @@ use PhpMyAdmin\UrlParams;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Medium;
use ReflectionMethod;
use ReflectionProperty;
use function hash;
@ -185,12 +186,8 @@ class InsertEditTest extends AbstractTestCase
$config,
new ResponseRenderer(),
);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'analyzeWhereClauses',
[$clauses, 'table', 'db'],
);
$result = (new ReflectionMethod(InsertEdit::class, 'analyzeWhereClauses'))
->invokeArgs($this->insertEdit, [$clauses, 'table', 'db']);
self::assertSame(
[[$resultStub1, $resultStub2], [['assoc1'], ['assoc2']], false],
@ -234,12 +231,8 @@ class InsertEditTest extends AbstractTestCase
new ResponseRenderer(),
);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'hasUniqueCondition',
[['1' => 1], $resultStub],
);
$result = (new ReflectionMethod(InsertEdit::class, 'hasUniqueCondition'))
->invokeArgs($this->insertEdit, [['1' => 1], $resultStub]);
self::assertTrue($result);
@ -272,12 +265,8 @@ class InsertEditTest extends AbstractTestCase
new ResponseRenderer(),
);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'loadFirstRow',
['table', 'db'],
);
$result = (new ReflectionMethod(InsertEdit::class, 'loadFirstRow'))
->invokeArgs($this->insertEdit, ['table', 'db']);
self::assertSame($resultStub, $result);
}
@ -298,12 +287,7 @@ class InsertEditTest extends AbstractTestCase
{
Config::getInstance()->set('InsertRows', $configValue);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getInsertRows',
[],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getInsertRows'))->invokeArgs($this->insertEdit, []);
self::assertSame($rowsValue, $result);
}
@ -365,24 +349,16 @@ class InsertEditTest extends AbstractTestCase
$fieldName = 'f1<';
self::assertSame(
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getColumnTitle',
[$fieldName, []],
),
(new ReflectionMethod(InsertEdit::class, 'getColumnTitle'))
->invokeArgs($this->insertEdit, [$fieldName, []]),
'f1&lt;',
);
$comments = [];
$comments['f1<'] = 'comment>';
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getColumnTitle',
[$fieldName, $comments],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getColumnTitle'))
->invokeArgs($this->insertEdit, [$fieldName, $comments]);
$result = $this->parseString($result);
@ -463,12 +439,8 @@ class InsertEditTest extends AbstractTestCase
);
self::assertSame(
'1',
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getNullifyCodeForNullColumn',
[$column, $foreigners, false],
),
(new ReflectionMethod(InsertEdit::class, 'getNullifyCodeForNullColumn'))
->invokeArgs($this->insertEdit, [$column, $foreigners, false]),
);
$column = new InsertEditColumn(
@ -486,35 +458,23 @@ class InsertEditTest extends AbstractTestCase
);
self::assertSame(
'2',
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getNullifyCodeForNullColumn',
[$column, $foreigners, false],
),
(new ReflectionMethod(InsertEdit::class, 'getNullifyCodeForNullColumn'))
->invokeArgs($this->insertEdit, [$column, $foreigners, false]),
);
$column = new InsertEditColumn('f', 'set', false, '', null, '', -1, false, false, false, false);
self::assertSame(
'3',
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getNullifyCodeForNullColumn',
[$column, $foreigners, false],
),
(new ReflectionMethod(InsertEdit::class, 'getNullifyCodeForNullColumn'))
->invokeArgs($this->insertEdit, [$column, $foreigners, false]),
);
$column = new InsertEditColumn('f', '', false, '', null, '', -1, false, false, false, false);
$foreigners = new Foreigners(['f' => ['y']]);
self::assertSame(
'4',
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getNullifyCodeForNullColumn',
[$column, $foreigners, false],
),
(new ReflectionMethod(InsertEdit::class, 'getNullifyCodeForNullColumn'))
->invokeArgs($this->insertEdit, [$column, $foreigners, false]),
);
}
@ -541,12 +501,8 @@ class InsertEditTest extends AbstractTestCase
false,
);
(new ReflectionProperty(InsertEdit::class, 'fieldIndex'))->setValue($this->insertEdit, 2);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getTextarea',
[$column, 'a', 'b', '', 'foobar', TypeClass::Char],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getTextarea'))
->invokeArgs($this->insertEdit, [$column, 'a', 'b', '', 'foobar', TypeClass::Char]);
$result = $this->parseString($result);
@ -564,24 +520,14 @@ class InsertEditTest extends AbstractTestCase
public function testGetMaxUploadSize(): void
{
$type = 'tinyblob';
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getMaxUploadSize',
[$type],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getMaxUploadSize'))->invokeArgs($this->insertEdit, [$type]);
self::assertSame("(Max: 256B)\n", $result);
// case 2
// this should stub Util::getUploadSizeInBytes() but it's not possible
$type = 'blob';
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getMaxUploadSize',
[$type],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getMaxUploadSize'))->invokeArgs($this->insertEdit, [$type]);
self::assertSame("(Max: 64KiB)\n", $result);
}
@ -598,10 +544,8 @@ class InsertEditTest extends AbstractTestCase
$extractedColumnSpec = '25';
(new ReflectionProperty(InsertEdit::class, 'fieldIndex'))->setValue($this->insertEdit, 22);
$result = $this->callFunction(
$result = (new ReflectionMethod(InsertEdit::class, 'getValueColumnForOtherDatatypes'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getValueColumnForOtherDatatypes',
[
$column,
'defchar',
@ -637,10 +581,8 @@ class InsertEditTest extends AbstractTestCase
false,
false,
);
$result = $this->callFunction(
$result = (new ReflectionMethod(InsertEdit::class, 'getValueColumnForOtherDatatypes'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getValueColumnForOtherDatatypes',
[
$column,
'defchar',
@ -682,10 +624,8 @@ class InsertEditTest extends AbstractTestCase
false,
false,
);
$result = $this->callFunction(
$result = (new ReflectionMethod(InsertEdit::class, 'getValueColumnForOtherDatatypes'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getValueColumnForOtherDatatypes',
[
$column,
'defchar',
@ -704,10 +644,8 @@ class InsertEditTest extends AbstractTestCase
// case 4: (else -> date)
$column = new InsertEditColumn('f', 'date', false, '', null, 'auto_increment', 20, false, false, false, false);
$result = $this->callFunction(
$result = (new ReflectionMethod(InsertEdit::class, 'getValueColumnForOtherDatatypes'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getValueColumnForOtherDatatypes',
[
$column,
'defchar',
@ -726,10 +664,8 @@ class InsertEditTest extends AbstractTestCase
// case 5: (else -> bit)
$column = new InsertEditColumn('f', 'bit', false, '', null, 'auto_increment', 20, false, false, false, false);
$result = $this->callFunction(
$result = (new ReflectionMethod(InsertEdit::class, 'getValueColumnForOtherDatatypes'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getValueColumnForOtherDatatypes',
[
$column,
'defchar',
@ -748,10 +684,8 @@ class InsertEditTest extends AbstractTestCase
// case 6: (else -> uuid)
$column = new InsertEditColumn('f', 'uuid', false, '', null, 'auto_increment', 20, false, false, false, false);
$result = $this->callFunction(
$result = (new ReflectionMethod(InsertEdit::class, 'getValueColumnForOtherDatatypes'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getValueColumnForOtherDatatypes',
[
$column,
'defchar',
@ -794,12 +728,8 @@ class InsertEditTest extends AbstractTestCase
self::assertSame(
40,
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getColumnSize',
[$column, $specInBrackets],
),
(new ReflectionMethod(InsertEdit::class, 'getColumnSize'))
->invokeArgs($this->insertEdit, [$column, $specInBrackets]),
);
self::assertSame('textarea', $config->config->CharEditing);
@ -820,12 +750,8 @@ class InsertEditTest extends AbstractTestCase
);
self::assertSame(
30,
$this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getColumnSize',
[$column, $specInBrackets],
),
(new ReflectionMethod(InsertEdit::class, 'getColumnSize'))
->invokeArgs($this->insertEdit, [$column, $specInBrackets]),
);
}
@ -878,12 +804,8 @@ class InsertEditTest extends AbstractTestCase
{
$urlParams = ['ShowFunctionFields' => 2];
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getHeadAndFootOfInsertRowTable',
[$urlParams],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getHeadAndFootOfInsertRowTable'))
->invokeArgs($this->insertEdit, [$urlParams]);
$result = $this->parseString($result);
@ -916,12 +838,8 @@ class InsertEditTest extends AbstractTestCase
false,
);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValueAndBackupFieldForExistingRow',
[$currentRow, $column, '', 'a', false],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValueAndBackupFieldForExistingRow'))
->invokeArgs($this->insertEdit, [$currentRow, $column, '', 'a', false]);
self::assertEquals(
[true, null, null, '<input type="hidden" name="fields_preva" value="">'],
@ -947,12 +865,8 @@ class InsertEditTest extends AbstractTestCase
false,
);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValueAndBackupFieldForExistingRow',
[$currentRow, $column, $extractedColumnSpec, 'a', false],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValueAndBackupFieldForExistingRow'))
->invokeArgs($this->insertEdit, [$currentRow, $column, $extractedColumnSpec, 'a', false]);
self::assertEquals(
[false, '00000000000001111011', null, '<input type="hidden" name="fields_preva" value="123">'],
@ -960,12 +874,8 @@ class InsertEditTest extends AbstractTestCase
);
$currentRow['f'] = 'abcd';
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValueAndBackupFieldForExistingRow',
[$currentRow, $column, $extractedColumnSpec, 'a', true],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValueAndBackupFieldForExistingRow'))
->invokeArgs($this->insertEdit, [$currentRow, $column, $extractedColumnSpec, 'a', true]);
self::assertEquals(
[false, 'abcd', null, '<input type="hidden" name="fields_preva" value="abcd">'],
@ -1006,12 +916,8 @@ class InsertEditTest extends AbstractTestCase
false,
);
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValueAndBackupFieldForExistingRow',
[$currentRow, $column, $extractedColumnSpec, 'a', false],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValueAndBackupFieldForExistingRow'))
->invokeArgs($this->insertEdit, [$currentRow, $column, $extractedColumnSpec, 'a', false]);
self::assertEquals(
[false, "'',", null, '<input type="hidden" name="fields_preva" value="\'\',">'],
@ -1035,12 +941,8 @@ class InsertEditTest extends AbstractTestCase
$currentRow['f'] = '11001';
$extractedColumnSpec = '20';
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValueAndBackupFieldForExistingRow',
[$currentRow, $column, $extractedColumnSpec, 'a', false],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValueAndBackupFieldForExistingRow'))
->invokeArgs($this->insertEdit, [$currentRow, $column, $extractedColumnSpec, 'a', false]);
self::assertSame(
[
@ -1055,12 +957,8 @@ class InsertEditTest extends AbstractTestCase
// Case 5
$currentRow['f'] = "11001\x00";
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValueAndBackupFieldForExistingRow',
[$currentRow, $column, $extractedColumnSpec, 'a', false],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValueAndBackupFieldForExistingRow'))
->invokeArgs($this->insertEdit, [$currentRow, $column, $extractedColumnSpec, 'a', false]);
self::assertSame(
[
@ -1083,12 +981,8 @@ class InsertEditTest extends AbstractTestCase
string $expected,
): void {
/** @var string $result */
$result = $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getDefaultValue',
[$defaultValue, $trueType],
);
$result = (new ReflectionMethod(InsertEdit::class, 'getDefaultValue'))
->invokeArgs($this->insertEdit, [$defaultValue, $trueType]);
self::assertSame($expected, $result);
}
@ -1343,12 +1237,8 @@ class InsertEditTest extends AbstractTestCase
new ResponseRenderer(),
);
$result = (array) $this->callFunction(
$this->insertEdit,
InsertEdit::class,
'getWarningMessages',
[],
);
$result = (array) (new ReflectionMethod(InsertEdit::class, 'getWarningMessages'))
->invokeArgs($this->insertEdit, []);
self::assertSame(['Error: #1001 Message 1', 'Warning: #1002 Message 2'], $result);
}
@ -2334,10 +2224,8 @@ class InsertEditTest extends AbstractTestCase
];
// Test w/ input transformation
$actual = $this->callFunction(
$actual = (new ReflectionMethod(InsertEdit::class, 'getHtmlForInsertEditFormColumn'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getHtmlForInsertEditFormColumn',
[
$tableColumn,
0,
@ -2378,10 +2266,8 @@ class InsertEditTest extends AbstractTestCase
// Test w/o input_transformation
$tableColumn = new Column('qwerty', 'datetime', null, true, '', null, '', 'insert,update,select', '');
$repopulate = [md5('qwerty') => '12-10-14'];
$actual = $this->callFunction(
$actual = (new ReflectionMethod(InsertEdit::class, 'getHtmlForInsertEditFormColumn'))->invokeArgs(
$this->insertEdit,
InsertEdit::class,
'getHtmlForInsertEditFormColumn',
[
$tableColumn,
0,

9
tests/unit/NormalizationTest.php
View File

@ -18,6 +18,7 @@ use PhpMyAdmin\Transformations;
use PhpMyAdmin\Types;
use PhpMyAdmin\UserPrivileges;
use PHPUnit\Framework\Attributes\CoversClass;
use ReflectionMethod;
use stdClass;
use function __;
@ -399,12 +400,8 @@ class NormalizationTest extends AbstractTestCase
public function testGetAllCombinationPartialKeys(): void
{
$primaryKey = ['id', 'col1', 'col2'];
$result = $this->callFunction(
$this->normalization,
Normalization::class,
'getAllCombinationPartialKeys',
[$primaryKey],
);
$result = (new ReflectionMethod(Normalization::class, 'getAllCombinationPartialKeys'))
->invokeArgs($this->normalization, [$primaryKey]);
self::assertSame(
['', 'id', 'col1', 'col1,id', 'col2', 'col2,id', 'col2,col1'],

68
tests/unit/SqlTest.php
View File

@ -75,12 +75,13 @@ class SqlTest extends AbstractTestCase
$_SESSION['tmpval']['pos'] = 1;
$_SESSION['tmpval']['max_rows'] = 2;
self::assertSame('SELECT * FROM test LIMIT 1, 2', $this->callFunction(
$this->sql,
Sql::class,
'getSqlWithLimitClause',
[ParseAnalyze::sqlQuery('SELECT * FROM test LIMIT 0, 10', Current::$database, false)[0]],
));
self::assertSame(
'SELECT * FROM test LIMIT 1, 2',
(new ReflectionMethod(Sql::class, 'getSqlWithLimitClause'))->invokeArgs(
$this->sql,
[ParseAnalyze::sqlQuery('SELECT * FROM test LIMIT 0, 10', Current::$database, false)[0]],
),
);
}
/**
@ -92,31 +93,31 @@ class SqlTest extends AbstractTestCase
Config::getInstance()->settings['RememberSorting'] = true;
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
(new ReflectionMethod(Sql::class, 'isRememberSortingOrder'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT * FROM tbl', Current::$database, false)[0],
]),
);
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
(new ReflectionMethod(Sql::class, 'isRememberSortingOrder'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT col FROM tbl', Current::$database, false)[0],
]),
);
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
(new ReflectionMethod(Sql::class, 'isRememberSortingOrder'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT 1', Current::$database, false)[0],
]),
);
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
(new ReflectionMethod(Sql::class, 'isRememberSortingOrder'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT col1, col2 FROM tbl', Current::$database, false)[0],
]),
);
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'isRememberSortingOrder', [
(new ReflectionMethod(Sql::class, 'isRememberSortingOrder'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT COUNT(*) from tbl', Current::$database, false)[0],
]),
);
@ -131,13 +132,13 @@ class SqlTest extends AbstractTestCase
$_SESSION['tmpval']['max_rows'] = 10;
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'isAppendLimitClause', [
(new ReflectionMethod(Sql::class, 'isAppendLimitClause'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT * FROM tbl', Current::$database, false)[0],
]),
);
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'isAppendLimitClause', [
(new ReflectionMethod(Sql::class, 'isAppendLimitClause'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT * from tbl LIMIT 0, 10', Current::$database, false)[0],
]),
);
@ -167,19 +168,19 @@ class SqlTest extends AbstractTestCase
public function testIsDeleteTransformationInfo(): void
{
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'isDeleteTransformationInfo', [
(new ReflectionMethod(Sql::class, 'isDeleteTransformationInfo'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('ALTER TABLE tbl DROP COLUMN col', Current::$database, false)[0],
]),
);
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'isDeleteTransformationInfo', [
(new ReflectionMethod(Sql::class, 'isDeleteTransformationInfo'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('DROP TABLE tbl', Current::$database, false)[0],
]),
);
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'isDeleteTransformationInfo', [
(new ReflectionMethod(Sql::class, 'isDeleteTransformationInfo'))->invokeArgs($this->sql, [
ParseAnalyze::sqlQuery('SELECT * from tbl', Current::$database, false)[0],
]),
);
@ -228,18 +229,18 @@ class SqlTest extends AbstractTestCase
$fieldsMeta = [$col1, $col2, $col3];
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
// should not matter on where the odd column occurs
$fieldsMeta = [$col2, $col3, $col1];
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
$fieldsMeta = [$col3, $col1, $col2];
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
}
@ -257,7 +258,7 @@ class SqlTest extends AbstractTestCase
$fieldsMeta = [$col1, $col2, $col3];
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
}
@ -276,18 +277,18 @@ class SqlTest extends AbstractTestCase
$fieldsMeta = [$col1, $col2, $col3];
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
// should not matter on where the function column occurs
$fieldsMeta = [$col2, $col3, $col1];
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
$fieldsMeta = [$col3, $col1, $col2];
self::assertTrue(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
}
@ -306,7 +307,7 @@ class SqlTest extends AbstractTestCase
$fieldsMeta = [$col1, $col2, $col3];
self::assertFalse(
$this->callFunction($this->sql, Sql::class, 'resultSetHasJustOneTable', [$fieldsMeta]),
(new ReflectionMethod(Sql::class, 'resultSetHasJustOneTable'))->invokeArgs($this->sql, [$fieldsMeta]),
);
}
@ -438,18 +439,13 @@ class SqlTest extends AbstractTestCase
);
}
$result = $this->callFunction(
$this->sql,
Sql::class,
'countQueryResults',
[
$numRows,
$justBrowsing,
'my_dataset',// db
'company_users',// table
ParseAnalyze::sqlQuery($sqlQuery ?? '', Current::$database, false)[0],
],
);
$result = (new ReflectionMethod(Sql::class, 'countQueryResults'))->invokeArgs($this->sql, [
$numRows,
$justBrowsing,
'my_dataset',// db
'company_users',// table
ParseAnalyze::sqlQuery($sqlQuery ?? '', Current::$database, false)[0],
]);
self::assertSame($expectedNumRows, $result);
$this->dummyDbi->assertAllQueriesConsumed();
}

17
tests/unit/Table/TableTest.php
View File

@ -25,6 +25,7 @@ use PhpMyAdmin\Tests\Stubs\DummyResult;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\MockObject\MockObject;
use ReflectionMethod;
use ReflectionProperty;
use const MYSQLI_TYPE_STRING;
@ -1290,24 +1291,16 @@ class TableTest extends AbstractTestCase
$tableObj = new Table('PMA_table', 'db', $this->mockedDbi);
$sql = $this->callFunction(
$tableObj,
Table::class,
'getSQLToCreateForeignKey',
[$table, $field, $foreignDb, $foreignTable, $foreignField],
);
$sql = (new ReflectionMethod(Table::class, 'getSQLToCreateForeignKey'))
->invokeArgs($tableObj, [$table, $field, $foreignDb, $foreignTable, $foreignField]);
$sqlExcepted = 'ALTER TABLE `PMA_table` ADD '
. 'FOREIGN KEY (`PMA_field1`, `PMA_field2`) REFERENCES '
. '`foreignDb`.`foreignTable`(`foreignField1`, `foreignField2`);';
self::assertSame($sqlExcepted, $sql);
// Exclude db name when relations are made between table in the same db
$sql = $this->callFunction(
$tableObj,
Table::class,
'getSQLToCreateForeignKey',
[$table, $field, 'db', $foreignTable, $foreignField],
);
$sql = (new ReflectionMethod(Table::class, 'getSQLToCreateForeignKey'))
->invokeArgs($tableObj, [$table, $field, 'db', $foreignTable, $foreignField]);
$sqlExcepted = 'ALTER TABLE `PMA_table` ADD '
. 'FOREIGN KEY (`PMA_field1`, `PMA_field2`) REFERENCES '
. '`foreignTable`(`foreignField1`, `foreignField2`);';

21
tests/unit/Utils/HttpRequestTest.php
View File

@ -13,6 +13,7 @@ use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Group;
use PHPUnit\Framework\Attributes\Medium;
use PHPUnit\Framework\Attributes\RequiresPhpExtension;
use ReflectionMethod;
use function curl_version;
use function ini_get;
@ -75,12 +76,8 @@ class HttpRequestTest extends AbstractTestCase
bool $returnOnlyStatus,
bool|string|null $expected,
): void {
$result = $this->callFunction(
$this->httpRequest,
HttpRequest::class,
'curl',
[$url, $method, $returnOnlyStatus],
);
$result = (new ReflectionMethod(HttpRequest::class, 'curl'))
->invokeArgs($this->httpRequest, [$url, $method, $returnOnlyStatus]);
$this->validateHttp($result, $expected);
}
@ -102,7 +99,7 @@ class HttpRequestTest extends AbstractTestCase
bool|string|null $expected,
): void {
$this->checkCurlSslFlagsSupport();
$result = $this->callFunction($this->httpRequest, HttpRequest::class, 'curl', [
$result = (new ReflectionMethod(HttpRequest::class, 'curl'))->invokeArgs($this->httpRequest, [
$url,
$method,
$returnOnlyStatus,
@ -131,7 +128,7 @@ class HttpRequestTest extends AbstractTestCase
bool|string|null $expected,
): void {
$this->checkCurlSslFlagsSupport();
$result = $this->callFunction($this->httpRequest, HttpRequest::class, 'curl', [
$result = (new ReflectionMethod(HttpRequest::class, 'curl'))->invokeArgs($this->httpRequest, [
$url,
$method,
$returnOnlyStatus,
@ -162,12 +159,8 @@ class HttpRequestTest extends AbstractTestCase
self::markTestSkipped('Configuration directive allow_url_fopen is not enabled.');
}
$result = $this->callFunction(
$this->httpRequest,
HttpRequest::class,
'fopen',
[$url, $method, $returnOnlyStatus],
);
$result = (new ReflectionMethod(HttpRequest::class, 'fopen'))
->invokeArgs($this->httpRequest, [$url, $method, $returnOnlyStatus]);
$this->validateHttp($result, $expected);
}