InstallerRedirectTraitTest.php

<?php

declare (strict_types=1);
namespace Drupal\KernelTests\Core\Installer;

use Drupal\Core\Database\Database;
use Drupal\Core\Database\DatabaseExceptionWrapper;
use Drupal\Core\Database\DatabaseNotFoundException;
use Drupal\Tests\Core\Database\Stub\StubConnection;
use Drupal\Tests\Core\Database\Stub\StubSchema;
use Drupal\KernelTests\KernelTestBase;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * @coversDefaultClass \Drupal\Core\Installer\InstallerRedirectTrait
 *
 * @group Installer
 */
class InstallerRedirectTraitTest extends KernelTestBase {
    
    /**
     * Data provider for testShouldRedirectToInstaller().
     *
     * @return array
     *   - Expected result from shouldRedirectToInstaller().
     *   - Exceptions to be handled by shouldRedirectToInstaller()
     *   - Whether or not there is a database connection.
     *   - Whether or not there is database connection info.
     *   - Whether or not there exists a sequences table in the database.
     */
    public static function providerShouldRedirectToInstaller() {
        return [
            [
                TRUE,
                DatabaseNotFoundException::class,
                FALSE,
                FALSE,
            ],
            [
                TRUE,
                DatabaseNotFoundException::class,
                TRUE,
                FALSE,
            ],
            [
                TRUE,
                DatabaseNotFoundException::class,
                FALSE,
                TRUE,
            ],
            [
                TRUE,
                DatabaseNotFoundException::class,
                TRUE,
                TRUE,
            ],
            [
                TRUE,
                DatabaseNotFoundException::class,
                TRUE,
                TRUE,
                FALSE,
            ],
            [
                TRUE,
                \PDOException::class,
                FALSE,
                FALSE,
            ],
            [
                TRUE,
                \PDOException::class,
                TRUE,
                FALSE,
            ],
            [
                FALSE,
                \PDOException::class,
                FALSE,
                TRUE,
            ],
            [
                FALSE,
                \PDOException::class,
                TRUE,
                TRUE,
            ],
            [
                TRUE,
                \PDOException::class,
                TRUE,
                TRUE,
                FALSE,
            ],
            [
                TRUE,
                DatabaseExceptionWrapper::class,
                FALSE,
                FALSE,
            ],
            [
                TRUE,
                DatabaseExceptionWrapper::class,
                TRUE,
                FALSE,
            ],
            [
                FALSE,
                DatabaseExceptionWrapper::class,
                FALSE,
                TRUE,
            ],
            [
                FALSE,
                DatabaseExceptionWrapper::class,
                TRUE,
                TRUE,
            ],
            [
                TRUE,
                DatabaseExceptionWrapper::class,
                TRUE,
                TRUE,
                FALSE,
            ],
            [
                TRUE,
                NotFoundHttpException::class,
                FALSE,
                FALSE,
            ],
            [
                TRUE,
                NotFoundHttpException::class,
                TRUE,
                FALSE,
            ],
            [
                FALSE,
                NotFoundHttpException::class,
                FALSE,
                TRUE,
            ],
            [
                FALSE,
                NotFoundHttpException::class,
                TRUE,
                TRUE,
            ],
            [
                TRUE,
                NotFoundHttpException::class,
                TRUE,
                TRUE,
                FALSE,
            ],
            [
                FALSE,
                \Exception::class,
                FALSE,
                FALSE,
            ],
            [
                FALSE,
                \Exception::class,
                TRUE,
                FALSE,
            ],
            [
                FALSE,
                \Exception::class,
                FALSE,
                TRUE,
            ],
            [
                FALSE,
                \Exception::class,
                TRUE,
                TRUE,
            ],
            [
                FALSE,
                \Exception::class,
                TRUE,
                TRUE,
                FALSE,
            ],
        ];
    }
    
    /**
     * @covers ::shouldRedirectToInstaller
     * @dataProvider providerShouldRedirectToInstaller
     */
    public function testShouldRedirectToInstaller(bool $expected, string $exception, bool $connection, bool $connection_info, bool $sequences_table_exists = TRUE) : void {
        // Mock the trait.
        $trait = $this->getMockBuilder(InstallerRedirectTraitMockableClass::class)
            ->onlyMethods([
            'isCli',
        ])
            ->getMock();
        // Make sure that the method thinks we are not using the cli.
        $trait->expects($this->any())
            ->method('isCli')
            ->willReturn(FALSE);
        // If testing no connection info, we need to make the 'default' key not
        // visible.
        if (!$connection_info) {
            Database::renameConnection('default', __METHOD__);
        }
        if ($connection) {
            // Mock the database connection.
            $connection = $this->getMockBuilder(StubConnection::class)
                ->disableOriginalConstructor()
                ->onlyMethods([
                'schema',
            ])
                ->getMock();
            if ($connection_info) {
                // Mock the database schema class.
                $schema = $this->getMockBuilder(StubSchema::class)
                    ->disableOriginalConstructor()
                    ->onlyMethods([
                    'tableExists',
                ])
                    ->getMock();
                $schema->expects($this->any())
                    ->method('tableExists')
                    ->with('sequences')
                    ->willReturn($sequences_table_exists);
                $connection->expects($this->any())
                    ->method('schema')
                    ->willReturn($schema);
            }
        }
        else {
            // Set the database connection if there is none.
            $connection = NULL;
        }
        try {
            throw new $exception();
        } catch (\Exception $e) {
            // Call shouldRedirectToInstaller.
            $method_ref = new \ReflectionMethod($trait, 'shouldRedirectToInstaller');
            $this->assertSame($expected, $method_ref->invoke($trait, $e, $connection));
        }
        if (!$connection_info) {
            Database::renameConnection(__METHOD__, 'default');
        }
    }

}