StagedDBUpdateValidatorTest.php

<?php

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

use Drupal\package_manager\PathLocator;
use Drupal\package_manager\ValidationResult;

/**
 * @covers \Drupal\package_manager\Validator\SandboxDatabaseUpdatesValidator
 * @group package_manager
 * @internal
 */
class StagedDBUpdateValidatorTest extends PackageManagerKernelTestBase {
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $this->container
            ->get('theme_installer')
            ->install([
            'stark',
        ]);
        $this->assertFalse($this->container
            ->get('module_handler')
            ->moduleExists('views'));
        $this->assertFalse($this->container
            ->get('theme_handler')
            ->themeExists('olivero'));
        // Ensure that all the extensions we're testing with have database update
        // files in the active directory.
        $active_dir = $this->container
            ->get(PathLocator::class)
            ->getProjectRoot();
        // System and Stark are installed, so they are used to test what happens
        // when database updates are detected in installed extensions. Views and
        // Olivero are not installed, so they are used to test what happens when
        // non-installed extensions have database updates.
        $extensions = [
            'core/modules/system',
            'core/themes/stark',
            'core/modules/views',
            'core/themes/olivero',
        ];
        foreach ($extensions as $extension_path) {
            $extension_path = $active_dir . '/' . $extension_path;
            mkdir($extension_path, 0777, TRUE);
            $extension_name = basename($extension_path);
            // Ensure each extension has a .install and a .post_update.php file with
            // an empty update function in it.
            foreach ([
                'install',
                'post_update.php',
            ] as $suffix) {
                $function_name = match ($suffix) {    'install' => $extension_name . '_update_1000',
                    'post_update.php' => $extension_name . '_post_update_test',
                
                };
                file_put_contents("{$extension_path}/{$extension_name}.{$suffix}", "<?php\nfunction {$function_name}() {}");
            }
        }
    }
    
    /**
     * Data provider for ::testStagedDatabaseUpdates().
     *
     * @return array[]
     *   The test cases.
     */
    public static function providerStagedDatabaseUpdate() : array {
        $summary = t('Database updates have been detected in the following extensions.');
        return [
            'schema update in installed module' => [
                'core/modules/system',
                'install',
                [
                    ValidationResult::createWarning([
                        t('System'),
                    ], $summary),
                ],
            ],
            'post-update in installed module' => [
                'core/modules/system',
                'post_update.php',
                [
                    ValidationResult::createWarning([
                        t('System'),
                    ], $summary),
                ],
            ],
            'schema update in installed theme' => [
                'core/themes/stark',
                'install',
                [
                    ValidationResult::createWarning([
                        t('Stark'),
                    ], $summary),
                ],
            ],
            'post-update in installed theme' => [
                'core/themes/stark',
                'post_update.php',
                [
                    ValidationResult::createWarning([
                        t('Stark'),
                    ], $summary),
                ],
            ],
            // The validator should ignore changes in any extensions that aren't
            // installed.
'schema update in non-installed module' => [
                'core/modules/views',
                'install',
                [],
            ],
            'post-update in non-installed module' => [
                'core/modules/views',
                'post_update.php',
                [],
            ],
            'schema update in non-installed theme' => [
                'core/themes/olivero',
                'install',
                [],
            ],
            'post-update in non-installed theme' => [
                'core/themes/olivero',
                'post_update.php',
                [],
            ],
        ];
    }
    
    /**
     * Tests validation of staged database updates.
     *
     * @param string $extension_dir
     *   The directory of the extension that should have database updates,
     *   relative to the stage directory.
     * @param string $file_extension
     *   The extension of the update file, without the leading period. Must be
     *   either `install` or `post_update.php`.
     * @param \Drupal\package_manager\ValidationResult[] $expected_results
     *   The expected validation results.
     *
     * @dataProvider providerStagedDatabaseUpdate
     */
    public function testStagedDatabaseUpdate(string $extension_dir, string $file_extension, array $expected_results) : void {
        $extension_name = basename($extension_dir);
        $relative_file_path = $extension_dir . '/' . $extension_name . '.' . $file_extension;
        $stage = $this->createStage();
        $stage->create();
        // Nothing has been changed in the stage, so ensure the validator doesn't
        // detect any changes.
        $this->assertStatusCheckResults([], $stage);
        $staged_update_file = $stage->getSandboxDirectory() . '/' . $relative_file_path;
        $this->assertFileIsWritable($staged_update_file);
        // Now add a "real" update function -- either a schema update or a
        // post-update, depending on what $file_extension is -- and ensure that the
        // validator detects it.
        $update_function_name = match ($file_extension) {    'install' => $extension_name . '_update_1001',
            'post_update.php' => $extension_name . '_post_update_' . $this->randomMachineName(),
        
        };
        file_put_contents($staged_update_file, "function {$update_function_name}() {}\n", FILE_APPEND);
        $this->assertStatusCheckResults($expected_results, $stage);
        // Add a bunch of functions which are named similarly to real schema update
        // and post-update functions, but not quite right, to ensure they are
        // ignored by the validator. Also throw an anonymous function in there to
        // ensure those are ignored as well.
        $code = <<<END
<?php
function {<span class="php-variable">$extension_name</span>}_update() { \$foo = function () {}; }
function {<span class="php-variable">$extension_name</span>}_update_string_123() {}
function {<span class="php-variable">$extension_name</span>}_update__123() {}
function ({<span class="php-variable">$extension_name</span>}}__post_update_test() {}
function ({<span class="php-variable">$extension_name</span>}}_post_update() {}
END;
        file_put_contents($staged_update_file, $code);
        $this->assertStatusCheckResults([], $stage);
        // If the update file is deleted from the stage, the validator should not
        // detect any database updates.
        unlink($staged_update_file);
        $this->assertStatusCheckResults([], $stage);
        // If the update file doesn't exist in the active directory, but does exist
        // in the stage with a legitimate schema update or post-update function, the
        // validator should detect it.
        $project_root = $this->container
            ->get(PathLocator::class)
            ->getProjectRoot();
        unlink($project_root . '/' . $relative_file_path);
        file_put_contents($staged_update_file, "<?php\nfunction {$update_function_name}() {}");
        $this->assertStatusCheckResults($expected_results, $stage);
    }
    
    /**
     * Tests that the validator disregards unclaimed stages.
     */
    public function testUnclaimedStage() : void {
        $stage = $this->createStage();
        $stage->create();
        $this->assertStatusCheckResults([], $stage);
        // A new, unclaimed stage should be ignored by the validator.
        $this->assertStatusCheckResults([], $this->createStage());
    }

}