upstream/nextcloud
1
0
Fork 0
mirror of https://github.com/nextcloud/server.git synced 2026-06-13 18:50:47 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 32

chore: apply code style

Browse source 
Signed-off-by: Ferdinand Thiessen <opensource@fthiessen.de>
This commit is contained in:
Ferdinand Thiessen 2026-06-11 17:19:41 +02:00
parent 97df391969
commit 9bc22fd2c4
No known key found for this signature in database
GPG key ID: 7E849AE05218500F
8 changed files with 350 additions and 350 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
core/Command/Db/DbIndexUsage.php
View file

@ -8,14 +8,14 @@ declare(strict_types=1);
*/
namespace OC\Core\Command\Db;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
use OC\DB\Connection;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
class DbIndexUsage extends Command {

14
core/Command/Db/DbInfo.php
View file

@ -8,15 +8,15 @@ declare(strict_types=1);
*/
namespace OC\Core\Command\Db;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
use Doctrine\DBAL\Platforms\SqlitePlatform;
use OC\DB\Connection;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
use Doctrine\DBAL\Platforms\SqlitePlatform;
class DbInfo extends Command {
@ -37,7 +37,7 @@ class DbInfo extends Command {
#[\Override]
protected function execute(InputInterface $input, OutputInterface $output): int {
$platform = $this->connection->getDatabasePlatform();
$asJson = $input->getOption('json');
$asJson = $input->getOption('json');
if ($platform instanceof MySQLPlatform) {
$rows = $this->getMySQLInfo();
@ -76,9 +76,9 @@ class DbInfo extends Command {
private function getMySQLInfo(): array {
$result = $this->connection->executeQuery(
"SELECT VERSION() AS version, @@innodb_buffer_pool_size AS buffer_pool,
'SELECT VERSION() AS version, @@innodb_buffer_pool_size AS buffer_pool,
@@max_connections AS max_conn, @@character_set_database AS charset,
@@transaction_isolation AS tx_isolation"
@@transaction_isolation AS tx_isolation'
);
$info = $result->fetchAssociative();
@ -114,7 +114,7 @@ class DbInfo extends Command {
private function getSQLiteInfo(): array {
$result = $this->connection->executeQuery('SELECT sqlite_version() AS version');
$info = $result->fetchAssociative();
$info = $result->fetchAssociative();
return [
['setting' => 'Engine', 'value' => 'SQLite'],
['setting' => 'Version', 'value' => $info['version']],

16
core/Command/Db/DbLocks.php
View file

@ -8,14 +8,14 @@ declare(strict_types=1);
*/
namespace OC\Core\Command\Db;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
use OC\DB\Connection;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
class DbLocks extends Command {
@ -39,7 +39,7 @@ class DbLocks extends Command {
$asJson = $input->getOption('json');
if ($platform instanceof MySQLPlatform) {
$sql = "SELECT r.trx_id AS waiting_trx_id,
$sql = 'SELECT r.trx_id AS waiting_trx_id,
r.trx_mysql_thread_id AS waiting_thread,
r.trx_query AS waiting_query,
b.trx_id AS blocking_trx_id,
@ -47,11 +47,11 @@ class DbLocks extends Command {
b.trx_query AS blocking_query
FROM information_schema.innodb_lock_waits w
JOIN information_schema.innodb_trx b ON b.trx_id = w.blocking_trx_id
JOIN information_schema.innodb_trx r ON r.trx_id = w.requesting_trx_id";
JOIN information_schema.innodb_trx r ON r.trx_id = w.requesting_trx_id';
$headers = ['Waiting TRX', 'Waiting Thread', 'Waiting Query', 'Blocking TRX', 'Blocking Thread', 'Blocking Query'];
$cols = ['waiting_trx_id', 'waiting_thread', 'waiting_query', 'blocking_trx_id', 'blocking_thread', 'blocking_query'];
} elseif ($platform instanceof PostgreSQLPlatform) {
$sql = "SELECT blocked_locks.pid AS blocked_pid,
$sql = 'SELECT blocked_locks.pid AS blocked_pid,
blocked_activity.usename AS blocked_user,
blocking_locks.pid AS blocking_pid,
blocking_activity.usename AS blocking_user,
@ -65,9 +65,9 @@ class DbLocks extends Command {
AND blocking_locks.relation IS NOT DISTINCT FROM blocked_locks.relation
AND blocking_locks.pid != blocked_locks.pid
JOIN pg_catalog.pg_stat_activity blocking_activity ON blocking_activity.pid = blocking_locks.pid
WHERE NOT blocked_locks.granted";
WHERE NOT blocked_locks.granted';
$headers = ['Blocked PID', 'Blocked User', 'Blocking PID', 'Blocking User', 'Blocked Query', 'Duration'];
$cols = ['blocked_pid', 'blocked_user', 'blocking_pid', 'blocking_user', 'blocked_query', 'blocked_duration'];
$cols = ['blocked_pid', 'blocked_user', 'blocking_pid', 'blocking_user', 'blocked_query', 'blocked_duration'];
} else {
$output->writeln('<comment>db:locks is not supported for SQLite and Oracle (SQLite uses file-level locking).</comment>');
return Command::SUCCESS;
@ -92,7 +92,7 @@ class DbLocks extends Command {
$table->setHeaders($headers);
foreach ($rows as $row) {
$table->addRow(array_map(fn($col) => $row[$col] ?? '—', $cols));
$table->addRow(array_map(fn ($col) => $row[$col] ?? '—', $cols));
}
$table->render();

16
core/Command/Db/DbSize.php
View file

@ -8,14 +8,14 @@ declare(strict_types=1);
*/
namespace OC\Core\Command\Db;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
use OC\DB\Connection;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Helper\Table;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Doctrine\DBAL\Platforms\MySQLPlatform;
use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
class DbSize extends Command {
@ -36,10 +36,10 @@ class DbSize extends Command {
#[\Override]
protected function execute(InputInterface $input, OutputInterface $output): int {
$platform = $this->connection->getDatabasePlatform();
$asJson = $input->getOption('json');
$asJson = $input->getOption('json');
if ($platform instanceof MySQLPlatform) {
$sql = "
$sql = '
SELECT table_name AS `table`,
ROUND((data_length + index_length) / 1024 / 1024, 2) AS total_mb,
ROUND(data_length / 1024 / 1024, 2) AS data_mb,
@ -49,9 +49,9 @@ class DbSize extends Command {
FROM information_schema.tables
WHERE table_schema = DATABASE()
ORDER BY (data_length + index_length) DESC
";
';
$headers = ['Table', 'Total (MB)', 'Data (MB)', 'Index (MB)', 'Rows', 'Avg Row (bytes)'];
$cols = ['table', 'total_mb', 'data_mb', 'index_mb', 'rows', 'avg_row_bytes'];
$cols = ['table', 'total_mb', 'data_mb', 'index_mb', 'rows', 'avg_row_bytes'];
} elseif ($platform instanceof PostgreSQLPlatform) {
$sql = "
SELECT relname AS table,
@ -66,7 +66,7 @@ class DbSize extends Command {
ORDER BY pg_total_relation_size(c.oid) DESC
";
$headers = ['Table', 'Total (MB)', 'Data (MB)', 'Index (MB)', 'Rows (est.)', 'Avg Row (bytes)'];
$cols = ['table', 'total_mb', 'data_mb', 'index_mb', 'rows', 'avg_row_bytes'];
$cols = ['table', 'total_mb', 'data_mb', 'index_mb', 'rows', 'avg_row_bytes'];
} else {
$output->writeln('<comment>db:size is not supported for SQLite and Oracle.</comment>');
return Command::SUCCESS;
@ -83,7 +83,7 @@ class DbSize extends Command {
$table->setHeaders($headers);
foreach ($rows as $row) {
$table->addRow(array_map(fn($col) => $row[$col], $cols));
$table->addRow(array_map(fn ($col) => $row[$col], $cols));
}
$table->render();

236
tests/Core/Command/Db/DbIndexUsageTest.php
View file

@ -22,148 +22,148 @@ use Test\TestCase;
class DbIndexUsageTest extends TestCase {
private Connection&MockObject $connection;
private InputInterface&MockObject $input;
private DbIndexUsage $command;
private Connection&MockObject $connection;
private InputInterface&MockObject $input;
private DbIndexUsage $command;
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbIndexUsage($this->connection);
}
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbIndexUsage($this->connection);
}
private function mockMySQLRows(): array {
return [
['table' => 'oc_filecache', 'index' => 'idx_fc_name', 'reads' => 0, 'writes' => 150],
['table' => 'oc_share', 'index' => 'idx_sh_par', 'reads' => 0, 'writes' => 42],
];
}
private function mockMySQLRows(): array {
return [
['table' => 'oc_filecache', 'index' => 'idx_fc_name', 'reads' => 0, 'writes' => 150],
['table' => 'oc_share', 'index' => 'idx_sh_par', 'reads' => 0, 'writes' => 42],
];
}
private function mockPostgreSQLRows(): array {
return [
['table' => 'oc_filecache', 'index' => 'idx_fc_name', 'reads' => 0, 'tuples_read' => 0, 'tuples_fetched' => 0],
];
}
private function mockPostgreSQLRows(): array {
return [
['table' => 'oc_filecache', 'index' => 'idx_fc_name', 'reads' => 0, 'tuples_read' => 0, 'tuples_fetched' => 0],
];
}
private function mockResult(array $rows): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAllAssociative')->willReturn($rows);
return $result;
}
private function mockResult(array $rows): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAllAssociative')->willReturn($rows);
return $result;
}
public function testNoUnusedIndexesPrintsSuccessMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
public function testNoUnusedIndexesPrintsSuccessMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('No unused indexes found', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('No unused indexes found', $output->fetch());
}
public function testMySQLUnusedIndexesRendersTable(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLRows()));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
public function testMySQLUnusedIndexesRendersTable(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLRows()));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$content = $output->fetch();
$this->assertStringContainsString('Reads', $content);
$this->assertStringContainsString('Writes', $content);
$this->assertStringContainsString('idx_fc_name', $content);
$this->assertStringContainsString('Found 2 unused index(es)', $content);
}
$this->assertSame(0, $exit);
$content = $output->fetch();
$this->assertStringContainsString('Reads', $content);
$this->assertStringContainsString('Writes', $content);
$this->assertStringContainsString('idx_fc_name', $content);
$this->assertStringContainsString('Found 2 unused index(es)', $content);
}
public function testPostgreSQLUnusedIndexesRendersTable(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockPostgreSQLRows()));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
public function testPostgreSQLUnusedIndexesRendersTable(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockPostgreSQLRows()));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$content = $output->fetch();
$this->assertStringContainsString('Tuples Read', $content);
$this->assertStringContainsString('Tuples Fetched', $content);
}
$this->assertSame(0, $exit);
$content = $output->fetch();
$this->assertStringContainsString('Tuples Read', $content);
$this->assertStringContainsString('Tuples Fetched', $content);
}
public function testAllFlagSuppressesCountMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLRows()));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', true]]);
public function testAllFlagSuppressesCountMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLRows()));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', true]]);
$output = new BufferedOutput();
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertStringNotContainsString('Found', $output->fetch());
}
$this->assertStringNotContainsString('Found', $output->fetch());
}
public function testDefaultFilterIncludedInQuery(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->expects($this->once())
->method('executeQuery')
->with($this->stringContains('count_read = 0'))
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
public function testDefaultFilterIncludedInQuery(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->expects($this->once())
->method('executeQuery')
->with($this->stringContains('count_read = 0'))
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
self::invokePrivate($this->command, 'execute', [$this->input, new BufferedOutput()]);
}
self::invokePrivate($this->command, 'execute', [$this->input, new BufferedOutput()]);
}
public function testAllFlagRemovesFilterFromQuery(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->expects($this->once())
->method('executeQuery')
->with($this->logicalNot($this->stringContains('count_read = 0')))
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', true]]);
public function testAllFlagRemovesFilterFromQuery(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->expects($this->once())
->method('executeQuery')
->with($this->logicalNot($this->stringContains('count_read = 0')))
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', true]]);
self::invokePrivate($this->command, 'execute', [$this->input, new BufferedOutput()]);
}
self::invokePrivate($this->command, 'execute', [$this->input, new BufferedOutput()]);
}
public function testJsonOutputWhenRowsExist(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLRows()));
$this->input->method('getOption')->willReturnMap([['json', true], ['all', false]]);
public function testJsonOutputWhenRowsExist(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLRows()));
$this->input->method('getOption')->willReturnMap([['json', true], ['all', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertCount(2, $data);
$this->assertArrayHasKey('table', $data[0]);
$this->assertArrayHasKey('index', $data[0]);
}
$this->assertSame(0, $exit);
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertCount(2, $data);
$this->assertArrayHasKey('table', $data[0]);
$this->assertArrayHasKey('index', $data[0]);
}
public function testSQLiteReturnsSuccessWithMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(SqlitePlatform::class));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
public function testSQLiteReturnsSuccessWithMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(SqlitePlatform::class));
$this->input->method('getOption')->willReturnMap([['json', false], ['all', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('not supported for SQLite', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('not supported for SQLite', $output->fetch());
}
}

34
tests/Core/Command/Db/DbInfoTest.php
View file

@ -30,17 +30,17 @@ class DbInfoTest extends TestCase {
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbInfo($this->connection);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbInfo($this->connection);
}
private function mockMySQLResult(array $overrides = []): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAssociative')->willReturn(array_merge([
'version' => '8.0.30',
'buffer_pool' => 1073741824, // 1 GB
'max_conn' => '200',
'charset' => 'utf8mb4',
'version' => '8.0.30',
'buffer_pool' => 1073741824, // 1 GB
'max_conn' => '200',
'charset' => 'utf8mb4',
'tx_isolation' => 'READ-COMMITTED',
], $overrides));
return $result;
@ -49,10 +49,10 @@ class DbInfoTest extends TestCase {
private function mockPostgreSQLResult(): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAssociative')->willReturn([
'version' => 'PostgreSQL 15.2 on x86_64',
'max_conn' => '100',
'version' => 'PostgreSQL 15.2 on x86_64',
'max_conn' => '100',
'shared_buffers' => '128MB',
'work_mem' => '4MB',
'work_mem' => '4MB',
]);
return $result;
}
@ -128,17 +128,17 @@ class DbInfoTest extends TestCase {
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertArrayHasKey('setting', $data[0]);
$this->assertArrayHasKey('value', $data[0]);
$this->assertArrayHasKey('value', $data[0]);
}
public static function dataMySQLHealthChecks(): array {
return [
'charset utf8mb4 → OK' => ['charset', 'utf8mb4', true, 'Character Set'],
'charset latin1 → CHECK' => ['charset', 'latin1', false, 'Character Set'],
'max_conn 200 → OK' => ['max_conn', '200', true, 'Max Connections'],
'max_conn 50 → CHECK' => ['max_conn', '50', false, 'Max Connections'],
'tx_isolation READ-COMMITTED → OK' => ['tx_isolation', 'READ-COMMITTED', true, 'Transaction Isolation'],
'tx_isolation REPEATABLE-READ → CHECK' => ['tx_isolation', 'REPEATABLE-READ', false, 'Transaction Isolation'],
'charset utf8mb4 → OK' => ['charset', 'utf8mb4', true, 'Character Set'],
'charset latin1 → CHECK' => ['charset', 'latin1', false, 'Character Set'],
'max_conn 200 → OK' => ['max_conn', '200', true, 'Max Connections'],
'max_conn 50 → CHECK' => ['max_conn', '50', false, 'Max Connections'],
'tx_isolation READ-COMMITTED → OK' => ['tx_isolation', 'READ-COMMITTED', true, 'Transaction Isolation'],
'tx_isolation REPEATABLE-READ → CHECK' => ['tx_isolation', 'REPEATABLE-READ', false, 'Transaction Isolation'],
];
}
@ -159,7 +159,7 @@ class DbInfoTest extends TestCase {
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$data = json_decode($output->fetch(), true);
$rows = array_values(array_filter($data, fn($r) => $r['setting'] === $settingLabel));
$rows = array_values(array_filter($data, fn ($r) => $r['setting'] === $settingLabel));
$this->assertNotEmpty($rows, "Setting '{$settingLabel}' not found in JSON output");
$this->assertSame($expectedOk, $rows[0]['ok']);
}

222
tests/Core/Command/Db/DbLocksTest.php
View file

@ -22,140 +22,140 @@ use Test\TestCase;
class DbLocksTest extends TestCase {
private Connection&MockObject $connection;
private InputInterface&MockObject $input;
private DbLocks $command;
private Connection&MockObject $connection;
private InputInterface&MockObject $input;
private DbLocks $command;
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbLocks($this->connection);
}
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbLocks($this->connection);
}
private function mockMySQLLocks(): array {
return [[
'waiting_trx_id' => '12345',
'waiting_thread' => '42',
'waiting_query' => 'UPDATE oc_filecache SET path_hash = ?',
'blocking_trx_id' => '12344',
'blocking_thread' => '41',
'blocking_query' => null, // NULL — deve ser renderizado como '—'
]];
}
private function mockMySQLLocks(): array {
return [[
'waiting_trx_id' => '12345',
'waiting_thread' => '42',
'waiting_query' => 'UPDATE oc_filecache SET path_hash = ?',
'blocking_trx_id' => '12344',
'blocking_thread' => '41',
'blocking_query' => null, // NULL — deve ser renderizado como '—'
]];
}
private function mockPostgreSQLLocks(): array {
return [[
'blocked_pid' => 1234,
'blocked_user' => 'nextcloud',
'blocking_pid' => 1233,
'blocking_user' => 'nextcloud',
'blocked_query' => 'SELECT * FROM oc_filecache WHERE parent = ?',
'blocked_duration' => '00:00:05.123456',
]];
}
private function mockPostgreSQLLocks(): array {
return [[
'blocked_pid' => 1234,
'blocked_user' => 'nextcloud',
'blocking_pid' => 1233,
'blocking_user' => 'nextcloud',
'blocked_query' => 'SELECT * FROM oc_filecache WHERE parent = ?',
'blocked_duration' => '00:00:05.123456',
]];
}
private function mockResult(array $rows): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAllAssociative')->willReturn($rows);
return $result;
}
private function mockResult(array $rows): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAllAssociative')->willReturn($rows);
return $result;
}
public function testMySQLNoLocksShowsInfoMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testMySQLNoLocksShowsInfoMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('No active locks', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('No active locks', $output->fetch());
}
public function testPostgreSQLNoLocksShowsInfoMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testPostgreSQLNoLocksShowsInfoMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult([]));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('No active locks', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('No active locks', $output->fetch());
}
public function testMySQLLocksFoundShowsErrorMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLLocks()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testMySQLLocksFoundShowsErrorMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLLocks()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('Found 1 blocking transaction(s)', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('Found 1 blocking transaction(s)', $output->fetch());
}
public function testPostgreSQLLocksFoundShowsErrorMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockPostgreSQLLocks()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testPostgreSQLLocksFoundShowsErrorMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockPostgreSQLLocks()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('Found 1 blocking transaction(s)', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('Found 1 blocking transaction(s)', $output->fetch());
}
public function testJsonOutputWhenLocksExist(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLLocks()));
$this->input->method('getOption')->willReturnMap([['json', true]]);
public function testJsonOutputWhenLocksExist(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLLocks()));
$this->input->method('getOption')->willReturnMap([['json', true]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertCount(1, $data);
$this->assertArrayHasKey('waiting_trx_id', $data[0]);
}
$this->assertSame(0, $exit);
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertCount(1, $data);
$this->assertArrayHasKey('waiting_trx_id', $data[0]);
}
public function testSQLiteReturnsSuccessWithMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(SqlitePlatform::class));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testSQLiteReturnsSuccessWithMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(SqlitePlatform::class));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('file-level locking', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('file-level locking', $output->fetch());
}
public function testNullColumnRenderedAsDash(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLLocks())); // blocking_query = null
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testNullColumnRenderedAsDash(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockMySQLLocks())); // blocking_query = null
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertStringContainsString('—', $output->fetch());
}
$this->assertStringContainsString('—', $output->fetch());
}
}

158
tests/Core/Command/Db/DbSizeTest.php
View file

@ -22,101 +22,101 @@ use Test\TestCase;
class DbSizeTest extends TestCase {
private Connection&MockObject $connection;
private InputInterface&MockObject $input;
private DbSize $command;
private Connection&MockObject $connection;
private InputInterface&MockObject $input;
private DbSize $command;
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbSize($this->connection);
}
protected function setUp(): void {
parent::setUp();
$this->connection = $this->createMock(Connection::class);
$this->input = $this->createMock(InputInterface::class);
$this->command = new DbSize($this->connection);
}
private function mockRows(): array {
return [
['table' => 'oc_filecache', 'total_mb' => 12.50, 'data_mb' => 10.00, 'index_mb' => 2.50, 'rows' => 5000, 'avg_row_bytes' => 2560],
['table' => 'oc_share', 'total_mb' => 3.25, 'data_mb' => 2.00, 'index_mb' => 1.25, 'rows' => 200, 'avg_row_bytes' => 16384],
];
}
private function mockRows(): array {
return [
['table' => 'oc_filecache', 'total_mb' => 12.50, 'data_mb' => 10.00, 'index_mb' => 2.50, 'rows' => 5000, 'avg_row_bytes' => 2560],
['table' => 'oc_share', 'total_mb' => 3.25, 'data_mb' => 2.00, 'index_mb' => 1.25, 'rows' => 200, 'avg_row_bytes' => 16384],
];
}
private function mockResult(array $rows): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAllAssociative')->willReturn($rows);
return $result;
}
private function mockResult(array $rows): Result&MockObject {
$result = $this->createMock(Result::class);
$result->method('fetchAllAssociative')->willReturn($rows);
return $result;
}
public function testMySQLOutputContainsTableAndTotal(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testMySQLOutputContainsTableAndTotal(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$content = $output->fetch();
$this->assertStringContainsString('oc_filecache', $content);
$this->assertStringContainsString('Total database size', $content);
}
$this->assertSame(0, $exit);
$content = $output->fetch();
$this->assertStringContainsString('oc_filecache', $content);
$this->assertStringContainsString('Total database size', $content);
}
public function testPostgreSQLOutputContainsTableAndTotal(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testPostgreSQLOutputContainsTableAndTotal(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(PostgreSQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('Total database size', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('Total database size', $output->fetch());
}
public function testSQLiteReturnsSuccessWithMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(SqlitePlatform::class));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testSQLiteReturnsSuccessWithMessage(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(SqlitePlatform::class));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$this->assertStringContainsString('not supported for SQLite', $output->fetch());
}
$this->assertSame(0, $exit);
$this->assertStringContainsString('not supported for SQLite', $output->fetch());
}
public function testJsonOutputIsValidArray(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', true]]);
public function testJsonOutputIsValidArray(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', true]]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
$exit = self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$this->assertSame(0, $exit);
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertCount(2, $data);
$this->assertArrayHasKey('table', $data[0]);
$this->assertArrayHasKey('total_mb', $data[0]);
}
$this->assertSame(0, $exit);
$data = json_decode($output->fetch(), true);
$this->assertIsArray($data);
$this->assertCount(2, $data);
$this->assertArrayHasKey('table', $data[0]);
$this->assertArrayHasKey('total_mb', $data[0]);
}
public function testTotalSizeCalculation(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
public function testTotalSizeCalculation(): void {
$this->connection->method('getDatabasePlatform')
->willReturn($this->createMock(MySQLPlatform::class));
$this->connection->method('executeQuery')
->willReturn($this->mockResult($this->mockRows()));
$this->input->method('getOption')->willReturnMap([['json', false]]);
$output = new BufferedOutput();
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
$output = new BufferedOutput();
self::invokePrivate($this->command, 'execute', [$this->input, $output]);
// 12.50 + 3.25 = 15.75
$this->assertStringContainsString('15.75', $output->fetch());
}
// 12.50 + 3.25 = 15.75
$this->assertStringContainsString('15.75', $output->fetch());
}
}