mirror of
https://github.com/nuxsmin/sysPass.git
synced 2026-03-03 07:04:07 +01:00
744 lines
22 KiB
PHP
744 lines
22 KiB
PHP
<?php
|
|
/*
|
|
* sysPass
|
|
*
|
|
* @author nuxsmin
|
|
* @link https://syspass.org
|
|
* @copyright 2012-2022, Rubén Domínguez nuxsmin@$syspass.org
|
|
*
|
|
* This file is part of sysPass.
|
|
*
|
|
* sysPass is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* sysPass is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with sysPass. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
namespace SP\Tests\Domain\Install\Services;
|
|
|
|
use PDOException;
|
|
use SP\Core\Exceptions\SPException;
|
|
use SP\Domain\Config\In\ConfigDataInterface;
|
|
use SP\Domain\Install\In\InstallData;
|
|
use SP\Domain\Install\Services\MysqlService;
|
|
use SP\Infrastructure\Database\DatabaseFileInterface;
|
|
use SP\Infrastructure\Database\DatabaseUtil;
|
|
use SP\Infrastructure\Database\DbStorageInterface;
|
|
use SP\Infrastructure\File\FileException;
|
|
use SP\Tests\Stubs\Pdo;
|
|
use SP\Tests\UnitaryTestCase;
|
|
|
|
/**
|
|
* Class MySQLTest
|
|
*
|
|
* @package SP\Tests\Services\Install
|
|
*/
|
|
class MySQLTest extends UnitaryTestCase
|
|
{
|
|
private DbStorageInterface $DBStorage;
|
|
private MysqlService $mysql;
|
|
private Pdo $pdo;
|
|
private InstallData $installData;
|
|
private ConfigDataInterface $configData;
|
|
private DatabaseFileInterface $databaseFile;
|
|
private DatabaseUtil $databaseUtil;
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testConnectDatabaseIsSuccessful(): void
|
|
{
|
|
$this->DBStorage->expects(self::once())->method('getConnectionSimple');
|
|
|
|
$this->mysql->connectDatabase();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testConnectDatabaseIsNotSuccessful(): void
|
|
{
|
|
$this->DBStorage->expects(self::once())
|
|
->method('getConnectionSimple')
|
|
->willThrowException(
|
|
new SPException('test')
|
|
);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage('Unable to connect to DB');
|
|
|
|
$this->mysql->connectDatabase();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testSetupUserIsSuccessful(): void
|
|
{
|
|
$this->pdo->mock('SELECT COUNT(*) FROM mysql.user WHERE `user` = ? AND (`host` = ? OR `host` = ?)', []);
|
|
|
|
[$user, $pass] = $this->mysql->setupDbUser();
|
|
|
|
$this->assertSame(preg_match('/sp_\w+/', $user), 1);
|
|
$this->assertNotEmpty($pass);
|
|
$this->assertEquals(16, strlen($pass));
|
|
|
|
}
|
|
|
|
public function testSetupUserIsNotSuccessful(): void
|
|
{
|
|
$this->pdo->mock('SELECT COUNT(*) FROM mysql.user WHERE `user` = ? AND (`host` = ? OR `host` = ?)', []);
|
|
|
|
$pdoException = new PDOException('test');
|
|
|
|
$this->DBStorage->expects(self::once())
|
|
->method('getConnectionSimple')
|
|
->willThrowException($pdoException);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessageMatches('/Unable to check the sysPass user \(sp_\w+\)/');
|
|
|
|
$this->mysql->setupDbUser();
|
|
}
|
|
|
|
public function testCheckDatabaseDoesNotExist(): void
|
|
{
|
|
$this->pdo->mock('SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1', [], []);
|
|
|
|
$this->assertFalse($this->mysql->checkDatabaseExists());
|
|
}
|
|
|
|
public function testCheckDatabaseExists(): void
|
|
{
|
|
$this->pdo->mock(
|
|
'SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1',
|
|
[[1]],
|
|
[$this->installData->getDbName()]
|
|
);
|
|
|
|
$this->assertTrue($this->mysql->checkDatabaseExists());
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsSuccessful(): void
|
|
{
|
|
$this->pdo->mock(
|
|
'SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1',
|
|
[],
|
|
[$this->installData->getDbName()]
|
|
);
|
|
|
|
$this->configData->setDbUser(self::$faker->userName);
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'CREATE SCHEMA `%s` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci',
|
|
$this->installData->getDbName()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'GRANT ALL PRIVILEGES ON `%s`.* TO %s@%s',
|
|
$this->installData->getDbName(),
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHost()
|
|
),
|
|
],
|
|
['FLUSH PRIVILEGES'],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(3))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->mysql->createDatabase($this->configData->getDbUser());
|
|
}
|
|
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsSuccessfulInHostingMode(): void
|
|
{
|
|
$this->installData->setHostingMode(true);
|
|
|
|
$this->pdo->expects(self::once())
|
|
->method('exec')
|
|
->with(
|
|
sprintf(
|
|
'USE `%s`',
|
|
$this->installData->getDbName()
|
|
)
|
|
);
|
|
|
|
$this->mysql->createDatabase();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsNotSuccessfulWithDuplicateDatabase(): void
|
|
{
|
|
$this->pdo->mock(
|
|
'SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1',
|
|
[[1]],
|
|
[$this->installData->getDbName()]
|
|
);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage('The database already exists');
|
|
|
|
$this->mysql->createDatabase();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsSuccessfulWithDns(): void
|
|
{
|
|
$this->pdo->mock(
|
|
'SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1',
|
|
[],
|
|
[$this->installData->getDbName()]
|
|
);
|
|
|
|
$this->configData->setDbUser(self::$faker->userName);
|
|
$this->installData->setDbAuthHostDns(self::$faker->domainName);
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'CREATE SCHEMA `%s` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci',
|
|
$this->installData->getDbName()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'GRANT ALL PRIVILEGES ON `%s`.* TO %s@%s',
|
|
$this->installData->getDbName(),
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHost()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'GRANT ALL PRIVILEGES ON `%s`.* TO %s@%s',
|
|
$this->installData->getDbName(),
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHostDns()
|
|
),
|
|
],
|
|
['FLUSH PRIVILEGES'],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(4))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->mysql->createDatabase($this->configData->getDbUser());
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsNotSuccessfulWithCreateError(): void
|
|
{
|
|
$this->pdo->mock(
|
|
'SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1',
|
|
[],
|
|
[$this->installData->getDbName()]
|
|
);
|
|
|
|
$pdoException = new PDOException('test');
|
|
|
|
$this->pdo->method('exec')
|
|
->with(
|
|
sprintf(
|
|
'CREATE SCHEMA `%s` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci',
|
|
$this->installData->getDbName()
|
|
),
|
|
)
|
|
->willThrowException($pdoException);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(sprintf(__('Error while creating the DB (\'%s\')'), $pdoException->getMessage()));
|
|
|
|
$this->mysql->createDatabase();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsNotSuccessfulWithPermissionError(): void
|
|
{
|
|
$this->pdo->mock(
|
|
'SELECT COUNT(*) FROM information_schema.schemata WHERE `schema_name` = ? LIMIT 1',
|
|
[],
|
|
[$this->installData->getDbName()]
|
|
);
|
|
|
|
$this->configData->setDbUser(self::$faker->userName);
|
|
|
|
$matcher = $this->any();
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'CREATE SCHEMA `%s` DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci',
|
|
$this->installData->getDbName()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'GRANT ALL PRIVILEGES ON `%s`.* TO %s@%s',
|
|
$this->installData->getDbName(),
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHost()
|
|
),
|
|
],
|
|
];
|
|
$pdoException = new PDOException('test');
|
|
|
|
$this->pdo->expects($matcher)
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments)
|
|
->willReturnCallback(function () use ($matcher, $pdoException) {
|
|
if ($matcher->getInvocationCount() === 3) {
|
|
throw $pdoException;
|
|
}
|
|
});
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(
|
|
sprintf(__('Error while setting the database permissions (\'%s\')'), $pdoException->getMessage())
|
|
);
|
|
|
|
$this->mysql->createDatabase($this->configData->getDbUser());
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDatabaseIsNotSuccessfulInHostingMode(): void
|
|
{
|
|
$this->installData->setHostingMode(true);
|
|
|
|
$pdoException = new PDOException('test');
|
|
|
|
$this->pdo->expects(self::once())
|
|
->method('exec')
|
|
->with(
|
|
sprintf(
|
|
'USE `%s`',
|
|
$this->installData->getDbName()
|
|
)
|
|
)->willThrowException($pdoException);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(
|
|
sprintf(
|
|
__('Error while selecting \'%s\' database (%s)'),
|
|
$this->installData->getDbName(),
|
|
$pdoException->getMessage()
|
|
)
|
|
);
|
|
|
|
$this->mysql->createDatabase();
|
|
}
|
|
|
|
public function testRollbackIsSuccessful(): void
|
|
{
|
|
$this->configData->setDbUser(self::$faker->userName);
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'DROP DATABASE IF EXISTS `%s`',
|
|
$this->installData->getDbName()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'DROP USER IF EXISTS %s@%s',
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHost()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'DROP USER IF EXISTS %s@%s',
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHostDns()
|
|
),
|
|
],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(3))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->mysql->rollback($this->configData->getDbUser());
|
|
}
|
|
|
|
public function testRollbackIsSuccessfulWithSameDnsHost(): void
|
|
{
|
|
$this->configData->setDbUser(self::$faker->userName);
|
|
$this->installData->setDbAuthHost('localhost');
|
|
$this->installData->setDbAuthHostDns('localhost');
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'DROP DATABASE IF EXISTS `%s`',
|
|
$this->installData->getDbName()
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'DROP USER IF EXISTS %s@%s',
|
|
$this->configData->getDbUser(),
|
|
$this->installData->getDbAuthHost()
|
|
),
|
|
],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(2))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->mysql->rollback($this->configData->getDbUser());
|
|
}
|
|
|
|
public function testRollbackIsSuccessfulWithHostingMode(): void
|
|
{
|
|
$this->installData->setHostingMode(true);
|
|
|
|
$dropRegex = '/DROP TABLE IF EXISTS `'.$this->installData->getDbName().'`\.`\w+`/';
|
|
$this->pdo->expects(self::exactly(count(DatabaseUtil::TABLES)))
|
|
->method('exec')
|
|
->with($this->callback(fn($arg) => preg_match($dropRegex, $arg) > 0));
|
|
|
|
$this->mysql->rollback();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBStructureIsSuccessful(): void
|
|
{
|
|
$execArguments = [
|
|
[
|
|
sprintf('USE `%s`', $this->installData->getDbName()),
|
|
],
|
|
[
|
|
'DROP TABLE IF EXISTS `Account`;',
|
|
],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(2))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->databaseFile->expects(self::once())
|
|
->method('parse')
|
|
->willReturn(['DROP TABLE IF EXISTS `Account`;']);
|
|
|
|
$this->mysql->createDBStructure();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBStructureIsNotSuccessfulWithUseDatabaseError(): void
|
|
{
|
|
$pdoException = new PDOException("test");
|
|
|
|
$this->pdo->expects(self::once())
|
|
->method('exec')
|
|
->with(sprintf('USE `%s`', $this->installData->getDbName()))
|
|
->willThrowException($pdoException);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(
|
|
sprintf(
|
|
__('Error while selecting \'%s\' database (%s)'),
|
|
$this->installData->getDbName(),
|
|
$pdoException->getMessage()
|
|
)
|
|
);
|
|
|
|
$this->mysql->createDBStructure();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBStructureIsNotSuccessfulWithCreateSchemaError(): void
|
|
{
|
|
$pdoException = new PDOException("test");
|
|
$execArguments = [
|
|
[
|
|
sprintf('USE `%s`', $this->installData->getDbName()),
|
|
],
|
|
[
|
|
'DROP TABLE IF EXISTS `Account`;',
|
|
],
|
|
[
|
|
sprintf(
|
|
'DROP DATABASE IF EXISTS `%s`',
|
|
$this->installData->getDbName()
|
|
),
|
|
]
|
|
];
|
|
$matcher = $this->exactly(3);
|
|
|
|
$this->pdo->expects($matcher)
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments)
|
|
->willReturnCallback(function () use ($matcher, $pdoException) {
|
|
if ($matcher->getInvocationCount() === 2) {
|
|
throw $pdoException;
|
|
}
|
|
});
|
|
|
|
$this->databaseFile->expects(self::once())
|
|
->method('parse')
|
|
->willReturn(['DROP TABLE IF EXISTS `Account`;']);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(
|
|
sprintf(__('Error while creating the DB (\'%s\')'), $pdoException->getMessage())
|
|
);
|
|
|
|
$this->mysql->createDBStructure();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBStructureIsNotSuccessfulWithParseSchemaError(): void
|
|
{
|
|
$fileException = new FileException("test");
|
|
$execArguments = [
|
|
[
|
|
sprintf('USE `%s`', $this->installData->getDbName()),
|
|
],
|
|
[
|
|
sprintf(
|
|
'DROP DATABASE IF EXISTS `%s`',
|
|
$this->installData->getDbName()
|
|
),
|
|
]
|
|
];
|
|
$matcher = $this->exactly(2);
|
|
|
|
$this->pdo->expects($matcher)
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->databaseFile->expects(self::once())
|
|
->method('parse')
|
|
->willThrowException($fileException);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(
|
|
sprintf(__('Error while creating the DB (\'%s\')'), $fileException->getMessage())
|
|
);
|
|
|
|
$this->mysql->createDBStructure();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCheckConnectionIsSuccessful(): void
|
|
{
|
|
$this->databaseUtil->expects(self::once())
|
|
->method('checkDatabaseTables')
|
|
->with($this->installData->getDbName())
|
|
->willReturn(true);
|
|
|
|
$this->mysql->checkConnection();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCheckConnectionIsNotSuccessful(): void
|
|
{
|
|
$this->databaseUtil->expects(self::once())
|
|
->method('checkDatabaseTables')
|
|
->with($this->installData->getDbName())
|
|
->willReturn(false);
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'DROP DATABASE IF EXISTS `%s`',
|
|
$this->installData->getDbName()
|
|
),
|
|
]
|
|
];
|
|
|
|
$this->pdo->expects(self::once())
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(__u('Error while checking the database'));
|
|
|
|
$this->mysql->checkConnection();
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBUserIsSuccessful(): void
|
|
{
|
|
$user = self::$faker->userName;
|
|
$pass = self::$faker->password;
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'CREATE USER %s@%s IDENTIFIED BY %s',
|
|
$user,
|
|
$this->installData->getDbAuthHost(),
|
|
$pass
|
|
),
|
|
],
|
|
[
|
|
'FLUSH PRIVILEGES',
|
|
],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(2))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->mysql->createDBUser($user, $pass);
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBUserIsSuccessfulWithDns(): void
|
|
{
|
|
$this->installData->setDbAuthHostDns(self::$faker->domainName);
|
|
|
|
$user = self::$faker->userName;
|
|
$pass = self::$faker->password;
|
|
|
|
$execArguments = [
|
|
[
|
|
sprintf(
|
|
'CREATE USER %s@%s IDENTIFIED BY %s',
|
|
$user,
|
|
$this->installData->getDbAuthHost(),
|
|
$pass
|
|
),
|
|
],
|
|
[
|
|
sprintf(
|
|
'CREATE USER %s@%s IDENTIFIED BY %s',
|
|
$user,
|
|
$this->installData->getDbAuthHostDns(),
|
|
$pass
|
|
),
|
|
],
|
|
[
|
|
'FLUSH PRIVILEGES',
|
|
],
|
|
];
|
|
|
|
$this->pdo->expects(self::exactly(3))
|
|
->method('exec')
|
|
->withConsecutive(...$execArguments);
|
|
|
|
$this->mysql->createDBUser($user, $pass);
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBUserIsSuccessfulWithHostingMode(): void
|
|
{
|
|
$this->installData->setHostingMode(true);
|
|
|
|
$user = self::$faker->userName;
|
|
$pass = self::$faker->password;
|
|
|
|
$this->pdo->expects(self::exactly(0))->method('exec');
|
|
|
|
$this->mysql->createDBUser($user, $pass);
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
public function testCreateDBUserIsNotSuccessful(): void
|
|
{
|
|
$user = self::$faker->userName;
|
|
$pass = self::$faker->password;
|
|
|
|
$this->pdo->expects(self::once())
|
|
->method('exec')
|
|
->willThrowException(new PDOException('test'));
|
|
|
|
$this->expectException(SPException::class);
|
|
$this->expectExceptionMessage(sprintf(__u('Error while creating the MySQL connection user \'%s\''), $user));
|
|
|
|
$this->mysql->createDBUser($user, $pass);
|
|
}
|
|
|
|
/**
|
|
* @throws \SP\Core\Exceptions\SPException
|
|
*/
|
|
protected function setUp(): void
|
|
{
|
|
parent::setUp();
|
|
|
|
$this->pdo = $this->getMockBuilder(Pdo::class)->enableProxyingToOriginalMethods()->getMock();
|
|
|
|
$this->DBStorage = $this->createMock(DbStorageInterface::class);
|
|
$this->DBStorage->method('getConnectionSimple')->willReturn($this->pdo);
|
|
$this->databaseFile = $this->createMock(DatabaseFileInterface::class);
|
|
|
|
$this->installData = $this->getInstallData();
|
|
$this->configData = $this->config->getConfigData();
|
|
$this->databaseUtil = $this->createMock(DatabaseUtil::class);
|
|
$this->mysql = new MysqlService(
|
|
$this->DBStorage, $this->installData, $this->databaseFile, $this->databaseUtil
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @return \SP\Domain\Install\In\InstallData
|
|
*/
|
|
private function getInstallData(): InstallData
|
|
{
|
|
$params = new InstallData();
|
|
$params->setDbAdminUser(self::$faker->userName);
|
|
$params->setDbAdminPass(self::$faker->password);
|
|
$params->setDbName(self::$faker->colorName);
|
|
$params->setDbHost(self::$faker->domainName);
|
|
$params->setAdminLogin(self::$faker->userName);
|
|
$params->setAdminPass(self::$faker->password);
|
|
$params->setMasterPassword(self::$faker->password(11));
|
|
$params->setSiteLang(self::$faker->languageCode);
|
|
$params->setDbAuthHost(self::$faker->ipv4);
|
|
|
|
return $params;
|
|
}
|
|
}
|