RecipeRunnerTest.php

<?php

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

use Drupal\Component\Plugin\Exception\PluginNotFoundException;
use Drupal\config_test\Entity\ConfigTest;
use Drupal\Core\Recipe\Recipe;
use Drupal\Core\Recipe\RecipePreExistingConfigException;
use Drupal\Core\Recipe\RecipeRunner;
use Drupal\FunctionalTests\Core\Recipe\RecipeTestTrait;
use Drupal\KernelTests\KernelTestBase;
use Drupal\node\Entity\NodeType;
use Drupal\views\Entity\View;

/**
 * @coversDefaultClass \Drupal\Core\Recipe\RecipeRunner
 * @group Recipe
 */
class RecipeRunnerTest extends KernelTestBase {
  use RecipeTestTrait;
  
  /**
   * Tests modules installed after processing a recipe.
   */
  public function testModuleInstall() : void {
    // Test the state prior to applying the recipe.
    $this->assertFalse($this->container
      ->get('module_handler')
      ->moduleExists('filter'), 'The filter module is not installed');
    $this->assertFalse($this->container
      ->get('module_handler')
      ->moduleExists('text'), 'The text module is not installed');
    $this->assertFalse($this->container
      ->get('module_handler')
      ->moduleExists('node'), 'The node module is not installed');
    $this->assertFalse($this->container
      ->get('config.storage')
      ->exists('node.settings'), 'The node.settings configuration does not exist');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/install_two_modules');
    RecipeRunner::processRecipe($recipe);
    // Test the state after applying the recipe.
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('filter'), 'The filter module is installed');
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('text'), 'The text module is installed');
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('node'), 'The node module is installed');
    $this->assertTrue($this->container
      ->get('config.storage')
      ->exists('node.settings'), 'The node.settings configuration has been created');
    $this->assertTrue($this->config('node.settings')
      ->get('use_admin_theme'), 'The node.settings:use_admin_theme is set to TRUE');
  }
  
  /**
   * Tests modules and themes installed after processing a recipe.
   */
  public function testModuleAndThemeInstall() : void {
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/base_theme_and_views');
    RecipeRunner::processRecipe($recipe);
    // Test the state after applying the recipe.
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('views'), 'The views module is installed');
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('node'), 'The node module is installed');
    $this->assertTrue($this->container
      ->get('theme_handler')
      ->themeExists('test_base_theme'), 'The test_base_theme theme is installed');
    $this->assertTrue($this->container
      ->get('theme_handler')
      ->themeExists('test_subtheme'), 'The test_subtheme theme is installed');
    $this->assertTrue($this->container
      ->get('theme_handler')
      ->themeExists('test_subsubtheme'), 'The test_subsubtheme theme is installed');
    $this->assertTrue($this->container
      ->get('config.storage')
      ->exists('node.settings'), 'The node.settings configuration has been created');
    $this->assertFalse($this->container
      ->get('config.storage')
      ->exists('views.view.archive'), 'The views.view.archive configuration has not been created');
    $this->assertEmpty(View::loadMultiple(), "No views exist");
  }
  
  /**
   * Tests module and theme dependencies installed after processing a recipe.
   */
  public function testThemeModuleDependenciesInstall() : void {
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/theme_with_module_dependencies');
    RecipeRunner::processRecipe($recipe);
    // Test the state after applying the recipe.
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('test_module_required_by_theme'), 'The test_module_required_by_theme module is installed');
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('test_another_module_required_by_theme'), 'The test_another_module_required_by_theme module is installed');
    $this->assertTrue($this->container
      ->get('theme_handler')
      ->themeExists('test_theme_depending_on_modules'), 'The test_theme_depending_on_modules theme is installed');
  }
  
  /**
   * Tests configuration override after processing a recipe.
   */
  public function testModuleConfigurationOverride() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('node.'), 'There is no node configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/install_node_with_config');
    RecipeRunner::processRecipe($recipe);
    // Test the state after applying the recipe.
    $this->assertTrue($this->container
      ->get('config.storage')
      ->exists('node.settings'), 'The node.settings configuration has been created');
    $this->assertTrue($this->container
      ->get('config.storage')
      ->exists('node.settings'), 'The node.settings configuration has been created');
    $this->assertFalse($this->config('node.settings')
      ->get('use_admin_theme'), 'The node.settings:use_admin_theme is set to FALSE');
    $this->assertSame('Test content type', NodeType::load('test')?->label());
    $node_type_data = $this->config('node.type.test')
      ->get();
    $this->assertGreaterThan(0, strlen($node_type_data['uuid']), 'The node type configuration has been assigned a UUID.');
    // cSpell:disable-next-line
    $this->assertSame('8Jlq8CmNXHVtNIHBHgFGpnAKthlUz0XoW_D0g56QXqY', $node_type_data['_core']['default_config_hash']);
  }
  
  /**
   * Tests applying a recipe multiple times.
   */
  public function testApplySameRecipe() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('node.'), 'There is no node configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/install_node_with_config');
    RecipeRunner::processRecipe($recipe);
    // Test the state prior to applying the recipe.
    $this->assertNotEmpty($this->container
      ->get('config.factory')
      ->listAll('node.'), 'There is node configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/install_node_with_config');
    RecipeRunner::processRecipe($recipe);
    $this->assertTrue(TRUE, 'Applying a recipe for the second time with no config changes results in a successful application');
    $type = NodeType::load('test');
    $type->setNewRevision(FALSE);
    $type->save();
    $this->expectException(RecipePreExistingConfigException::class);
    $this->expectExceptionMessage("The configuration 'node.type.test' exists already and does not match the recipe's configuration");
    Recipe::createFromDirectory('core/tests/fixtures/recipes/install_node_with_config');
  }
  
  /**
   * Tests module configuration after processing a recipe.
   */
  public function testConfigFromModule() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is no config_test configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/config_from_module');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $this->assertNotEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is config_test configuration');
    $config_test_entities = \Drupal::entityTypeManager()->getStorage('config_test')
      ->loadMultiple();
    $this->assertSame([
      'dotted.default',
      'override',
    ], array_keys($config_test_entities));
  }
  
  /**
   * Tests processing a recipe with a wildcard configuration.
   */
  public function testConfigWildcard() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is no config_test configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/config_wildcard');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $this->assertNotEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is config_test configuration');
    $config_test_entities = \Drupal::entityTypeManager()->getStorage('config_test')
      ->loadMultiple();
    $this->assertSame([
      'dotted.default',
      'override',
      'override_unmet',
    ], array_keys($config_test_entities));
    $this->assertSame('Default', $config_test_entities['dotted.default']->label());
    $this->assertSame('herp', $this->config('config_test.system')
      ->get('404'));
  }
  
  /**
   * Tests installing config from a module and a recipe.
   */
  public function testConfigFromModuleAndRecipe() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is no config_test configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/config_from_module_and_recipe');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $this->assertNotEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is config_test configuration');
    $config_test_entities = \Drupal::entityTypeManager()->getStorage('config_test')
      ->loadMultiple();
    $this->assertSame([
      'dotted.default',
      'override',
      'override_unmet',
    ], array_keys($config_test_entities));
    $this->assertSame('Provided by recipe', $config_test_entities['dotted.default']->label());
    $this->assertSame('foo', $this->config('config_test.system')
      ->get('404'));
  }
  
  /**
   * Tests processing a recipe that includes another recipe.
   */
  public function testRecipeInclude() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('node.'), 'There is no node configuration');
    $this->assertFalse($this->container
      ->get('module_handler')
      ->moduleExists('dblog'), 'Dblog module not installed');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/recipe_include');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('dblog'), 'Dblog module installed');
    $this->assertSame('Test content type', NodeType::load('test')?->label());
    $this->assertSame('Another test content type', NodeType::load('another_test')?->label());
  }
  
  /**
   * Tests a recipe that has actions.
   */
  public function testConfigActions() : void {
    // Test the state prior to applying the recipe.
    $this->assertEmpty($this->container
      ->get('config.factory')
      ->listAll('config_test.'), 'There is no config_test configuration');
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/config_actions');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $storage = \Drupal::entityTypeManager()->getStorage('config_test');
    $config_test_entity = $storage->load('recipe');
    $this->assertInstanceOf(ConfigTest::class, $config_test_entity);
    $this->assertSame('Created by recipe', $config_test_entity->label());
    $this->assertSame('Set by recipe', $config_test_entity->getProtectedProperty());
    $this->assertSame('not bar', $this->config('config_test.system')
      ->get('foo'));
  }
  
  /**
   * Tests a recipe that has actions and with pre-existing configuration.
   */
  public function testConfigActionsPreExistingConfig() : void {
    $this->enableModules([
      'config_test',
    ]);
    $this->installConfig([
      'config_test',
    ]);
    $this->assertSame('bar', $this->config('config_test.system')
      ->get('foo'));
    $storage = \Drupal::entityTypeManager()->getStorage('config_test');
    $config_test_entity = $storage->create([
      'id' => 'recipe',
      'label' => 'Created by test',
    ]);
    $this->assertInstanceOf(ConfigTest::class, $config_test_entity);
    $config_test_entity->setProtectedProperty('Set by test');
    $config_test_entity->save();
    $recipe = Recipe::createFromDirectory('core/tests/fixtures/recipes/config_actions');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $config_test_entity = $storage->load('recipe');
    $this->assertInstanceOf(ConfigTest::class, $config_test_entity);
    $this->assertSame('Created by test', $config_test_entity->label());
    $this->assertSame('Set by recipe', $config_test_entity->getProtectedProperty());
    $this->assertSame('not bar', $this->config('config_test.system')
      ->get('foo'));
  }
  
  /**
   * Tests a recipe with an invalid configuration action.
   */
  public function testInvalidConfigAction() : void {
    $recipe_data = <<<YAML
name: Invalid config action
install:
  - config_test
config:
  actions:
    config_test.system:
      setFoo: 'Bar'
YAML;
    $recipe = $this->createRecipe($recipe_data);
    $this->expectException(PluginNotFoundException::class);
    $this->expectExceptionMessage('The "setFoo" plugin does not exist.');
    RecipeRunner::processRecipe($recipe);
  }
  
  /**
   * Tests a recipe with an invalid action configuration.
   */
  public function testInvalidConfigActionAppliedOnConfigEntity() : void {
    $recipe_data = <<<YAML
name: Invalid config action
install:
  - config_test
config:
  actions:
    config_test.dynamic.recipe:
      createIfNotExists:
        label: 'Created by recipe'
      setBody: 'Description set by recipe'
YAML;
    $recipe = $this->createRecipe($recipe_data);
    $this->expectException(PluginNotFoundException::class);
    $this->expectExceptionMessage('The "config_test" entity does not support the "setBody" config action.');
    RecipeRunner::processRecipe($recipe);
  }
  
  /**
   * Tests that renamed plugins are marked as deprecated.
   *
   * @group legacy
   */
  public function testRenamedConfigActions() : void {
    $recipe_data = <<<YAML
name: Renamed config action
install:
  - config_test
config:
  actions:
    config_test.dynamic.recipe:
      ensure_exists:
        label: 'Created by recipe'
YAML;
    $recipe = $this->createRecipe($recipe_data);
    $this->expectDeprecation('The plugin ID "entity_create:ensure_exists" is deprecated in drupal:10.3.1 and will be removed in drupal:12.0.0. Use "entity_create:createIfNotExists" instead. See https://www.drupal.org/node/3458273.');
    RecipeRunner::processRecipe($recipe);
  }
  
  /**
   * Tests recipes are distinguished by the file path.
   */
  public function testRecipesAreDisambiguatedByPath() : void {
    $recipe_data = <<<YAML
name: 'Recipe include'
recipes:
  - core/tests/fixtures/recipes/recipe_include
install:
  - config_test
YAML;
    $recipe = $this->createRecipe($recipe_data, 'recipe_include');
    RecipeRunner::processRecipe($recipe);
    // Test the state after to applying the recipe.
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('dblog'), 'Dblog module installed');
    $this->assertTrue($this->container
      ->get('module_handler')
      ->moduleExists('config_test'), 'Config test module installed');
    $this->assertSame('Test content type', NodeType::load('test')?->label());
    $this->assertSame('Another test content type', NodeType::load('another_test')?->label());
    $operations = RecipeRunner::toBatchOperations($recipe);
    $this->assertSame('triggerEvent', $operations[7][0][1]);
    $this->assertSame('Install node with config', $operations[7][1][0]->name);
    $this->assertStringEndsWith('core/tests/fixtures/recipes/install_node_with_config', $operations[7][1][0]->path);
    $this->assertSame('triggerEvent', $operations[10][0][1]);
    $this->assertSame('Recipe include', $operations[10][1][0]->name);
    $this->assertStringEndsWith('core/tests/fixtures/recipes/recipe_include', $operations[10][1][0]->path);
    $this->assertSame('triggerEvent', $operations[12][0][1]);
    $this->assertSame('Recipe include', $operations[12][1][0]->name);
    $this->assertSame($this->siteDirectory . '/recipes/recipe_include', $operations[12][1][0]->path);
  }

}