SqliteDatabaseExcluderTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\package_manager\Kernel\PathExcluder;

use Drupal\Core\Database\Connection;
use Drupal\Core\DependencyInjection\ContainerBuilder;
use Drupal\package_manager\Event\CollectPathsToExcludeEvent;
use Drupal\package_manager\PathExcluder\SqliteDatabaseExcluder;
use Drupal\package_manager\PathLocator;
use Drupal\Tests\package_manager\Kernel\PackageManagerKernelTestBase;
use PhpTuf\ComposerStager\API\Path\Factory\PathFactoryInterface;
use Prophecy\Prophecy\ObjectProphecy;
use Symfony\Component\DependencyInjection\Reference;

/**
 * @covers \Drupal\package_manager\PathExcluder\SqliteDatabaseExcluder
 * @group package_manager
 * @internal
 */
class SqliteDatabaseExcluderTest extends PackageManagerKernelTestBase {
    
    /**
     * The mocked database connection.
     *
     * @var \Drupal\Core\Database\Connection|\Prophecy\Prophecy\ObjectProphecy
     */
    private Connection|ObjectProphecy $mockDatabase;
    
    /**
     * {@inheritdoc}
     */
    public function register(ContainerBuilder $container) : void {
        parent::register($container);
        $this->mockDatabase = $this->prophesize(Connection::class);
        $this->mockDatabase
            ->driver()
            ->willReturn('sqlite')
            ->shouldBeCalled();
        $container->set('mock_database', $this->mockDatabase
            ->reveal());
        $container->getDefinition(SqliteDatabaseExcluder::class)
            ->setArgument('$database', new Reference('mock_database'));
    }
    
    /**
     * Data provider for ::testSqliteDatabaseFilesExcluded().
     *
     * @return array[]
     *   The test cases.
     */
    public static function providerSqliteDatabaseFilesExcluded() : array {
        return [
            // If the database is at a relative path, it should be excluded relative
            // to the web root.
'relative path in relocated web root' => [
                'www',
                'db.sqlite',
                'www/db.sqlite',
            ],
            'relative path, web root is project root' => [
                '',
                'db.sqlite',
                'db.sqlite',
            ],
            // If the database is at an absolute path in the project root, it should
            // be excluded relative to the project root.
'absolute path in relocated web root' => [
                'www',
                '<PROJECT_ROOT>/www/db.sqlite',
                'www/db.sqlite',
            ],
            'absolute path, web root is project root' => [
                '',
                '<PROJECT_ROOT>/db.sqlite',
                'db.sqlite',
            ],
            // If the database is outside the project root, the excluder doesn't need
            // to do anything.
'absolute path outside of project, relocated web root' => [
                'www',
                '/path/to/database.sqlite',
                FALSE,
            ],
            'absolute path outside of project, web root is project root' => [
                '',
                '/path/to/database.sqlite',
                FALSE,
            ],
        ];
    }
    
    /**
     * Tests that SQLite database files are excluded from stage operations.
     *
     * @param string $web_root
     *   The web root that should be returned by the path locator. See
     *   \Drupal\package_manager\PathLocator::getWebRoot().
     * @param string $db_path
     *   The path of the SQLite database, as it should be reported by the database
     *   connection. This can be a relative or absolute path; it does not need to
     *   actually exist.
     * @param string|false $expected_excluded_path
     *   The path to the database, as it should be given to
     *   CollectPathsToExcludeEvent. If FALSE, the database is located outside the
     *   project and therefore is not excluded.
     *
     * @dataProvider providerSqliteDatabaseFilesExcluded
     */
    public function testSqliteDatabaseFilesExcluded(string $web_root, string $db_path, string|false $expected_excluded_path) : void {
        
        /** @var \Drupal\package_manager_bypass\MockPathLocator $path_locator */
        $path_locator = $this->container
            ->get(PathLocator::class);
        $project_root = $path_locator->getProjectRoot();
        // Set the mocked web root, keeping everything else as-is.
        $path_locator->setPaths($project_root, $path_locator->getVendorDirectory(), $web_root, $path_locator->getStagingRoot());
        $db_path = str_replace('<PROJECT_ROOT>', $project_root, $db_path);
        $this->mockDatabase
            ->getConnectionOptions()
            ->willReturn([
            'database' => $db_path,
        ])
            ->shouldBeCalled();
        $event = new CollectPathsToExcludeEvent($this->createStage(), $path_locator, $this->container
            ->get(PathFactoryInterface::class));
        $actual_excluded_paths = $this->container
            ->get('event_dispatcher')
            ->dispatch($event)
            ->getAll();
        if (is_string($expected_excluded_path)) {
            $expected_exclusions = [
                $expected_excluded_path,
                $expected_excluded_path . '-shm',
                $expected_excluded_path . '-wal',
            ];
            $this->assertEmpty(array_diff($expected_exclusions, $actual_excluded_paths));
        }
        else {
            // The path of the database should not appear anywhere in the list of
            // excluded paths.
            $this->assertStringNotContainsString($db_path, serialize($actual_excluded_paths));
        }
    }

}