LanguageConfigurationElementTest.php

<?php

declare (strict_types=1);
namespace Drupal\Tests\language\Functional;

use Drupal\Core\Language\LanguageInterface;
use Drupal\language\Entity\ConfigurableLanguage;
use Drupal\language\Entity\ContentLanguageSettings;
use Drupal\taxonomy\Entity\Vocabulary;
use Drupal\Tests\BrowserTestBase;

/**
 * Tests the features of the language configuration element field.
 *
 * @group language
 */
class LanguageConfigurationElementTest extends BrowserTestBase {
    
    /**
     * Modules to enable.
     *
     * @var array
     */
    protected static $modules = [
        'taxonomy',
        'node',
        'language',
        'language_elements_test',
        'field_ui',
    ];
    
    /**
     * {@inheritdoc}
     */
    protected $defaultTheme = 'stark';
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        parent::setUp();
        $user = $this->drupalCreateUser([
            'access administration pages',
            'administer languages',
            'administer content types',
        ]);
        $this->drupalLogin($user);
    }
    
    /**
     * Tests the language settings have been saved.
     */
    public function testLanguageConfigurationElement() : void {
        $this->drupalGet('language-tests/language_configuration_element');
        $edit['lang_configuration[langcode]'] = 'current_interface';
        $edit['lang_configuration[language_alterable]'] = FALSE;
        $this->submitForm($edit, 'Save');
        $lang_conf = ContentLanguageSettings::loadByEntityTypeBundle('entity_test', 'some_bundle');
        // Check that the settings have been saved.
        $this->assertEquals('current_interface', $lang_conf->getDefaultLangcode());
        $this->assertFalse($lang_conf->isLanguageAlterable());
        $this->drupalGet('language-tests/language_configuration_element');
        $this->assertTrue($this->assertSession()
            ->optionExists('edit-lang-configuration-langcode', 'current_interface')
            ->isSelected());
        $this->assertSession()
            ->checkboxNotChecked('edit-lang-configuration-language-alterable');
        // Reload the page and save again.
        $this->drupalGet('language-tests/language_configuration_element');
        $edit['lang_configuration[langcode]'] = 'authors_default';
        $edit['lang_configuration[language_alterable]'] = TRUE;
        $this->submitForm($edit, 'Save');
        $lang_conf = ContentLanguageSettings::loadByEntityTypeBundle('entity_test', 'some_bundle');
        // Check that the settings have been saved.
        $this->assertEquals('authors_default', $lang_conf->getDefaultLangcode());
        $this->assertTrue($lang_conf->isLanguageAlterable());
        $this->drupalGet('language-tests/language_configuration_element');
        $this->assertTrue($this->assertSession()
            ->optionExists('edit-lang-configuration-langcode', 'authors_default')
            ->isSelected());
        $this->assertSession()
            ->checkboxChecked('edit-lang-configuration-language-alterable');
        // Test if content type settings have been saved.
        $edit = [
            'name' => 'Page',
            'type' => 'page',
            'language_configuration[langcode]' => 'authors_default',
            'language_configuration[language_alterable]' => TRUE,
        ];
        $this->drupalGet('admin/structure/types/add');
        $this->submitForm($edit, 'Save and manage fields');
        // Make sure the settings are saved when creating the content type.
        $this->drupalGet('admin/structure/types/manage/page');
        $this->assertTrue($this->assertSession()
            ->optionExists('edit-language-configuration-langcode', 'authors_default')
            ->isSelected());
        $this->assertSession()
            ->checkboxChecked('edit-language-configuration-language-alterable');
    }
    
    /**
     * Tests that the language_get_default_langcode() returns the correct values.
     */
    public function testDefaultLangcode() : void {
        // Add some custom languages.
        foreach ([
            'aa',
            'bb',
            'cc',
        ] as $language_code) {
            ConfigurableLanguage::create([
                'id' => $language_code,
                'label' => $this->randomMachineName(),
            ])
                ->save();
        }
        // Ensure the bundles under test exist, to avoid config validation errors.
        entity_test_create_bundle('custom_bundle');
        entity_test_create_bundle('some_bundle');
        // Fixed language.
        ContentLanguageSettings::loadByEntityTypeBundle('entity_test', 'custom_bundle')->setLanguageAlterable(TRUE)
            ->setDefaultLangcode('bb')
            ->save();
        $langcode = language_get_default_langcode('entity_test', 'custom_bundle');
        $this->assertEquals('bb', $langcode);
        // Current interface.
        ContentLanguageSettings::loadByEntityTypeBundle('entity_test', 'custom_bundle')->setLanguageAlterable(TRUE)
            ->setDefaultLangcode('current_interface')
            ->save();
        $langcode = language_get_default_langcode('entity_test', 'custom_bundle');
        $language_interface = \Drupal::languageManager()->getCurrentLanguage();
        $this->assertEquals($langcode, $language_interface->getId());
        // Site's default.
        $old_default = \Drupal::languageManager()->getDefaultLanguage();
        // Ensure the language entity default value is correct.
        $configurable_language = ConfigurableLanguage::load($old_default->getId());
        $this->assertTrue($configurable_language->isDefault(), 'The en language entity is flagged as the default language.');
        $this->config('system.site')
            ->set('default_langcode', 'cc')
            ->save();
        ContentLanguageSettings::loadByEntityTypeBundle('entity_test', 'custom_bundle')->setLanguageAlterable(TRUE)
            ->setDefaultLangcode(LanguageInterface::LANGCODE_SITE_DEFAULT)
            ->save();
        $langcode = language_get_default_langcode('entity_test', 'custom_bundle');
        $this->assertEquals('cc', $langcode);
        // Ensure the language entity default value is correct.
        $configurable_language = ConfigurableLanguage::load($old_default->getId());
        $this->assertFalse($configurable_language->isDefault(), 'The en language entity is not flagged as the default language.');
        $configurable_language = ConfigurableLanguage::load('cc');
        // Check calling the
        // \Drupal\language\ConfigurableLanguageInterface::isDefault() method
        // directly.
        $this->assertTrue($configurable_language->isDefault(), 'The cc language entity is flagged as the default language.');
        // Check the default value of a language field when authors preferred option
        // is selected.
        // First create a user, then assign a langcode.
        $some_user = $this->drupalCreateUser();
        $some_user->preferred_langcode = 'bb';
        $some_user->save();
        $this->drupalLogin($some_user);
        ContentLanguageSettings::create([
            'target_entity_type_id' => 'entity_test',
            'target_bundle' => 'some_bundle',
        ])->setLanguageAlterable(TRUE)
            ->setDefaultLangcode('authors_default')
            ->save();
        $this->drupalGet('language-tests/language_configuration_element_test');
        $this->assertTrue($this->assertSession()
            ->optionExists('edit-langcode', 'bb')
            ->isSelected());
    }
    
    /**
     * Tests that the configuration is retained when the node type is updated.
     */
    public function testNodeTypeUpdate() : void {
        // Create the article content type first if the profile used is not the
        // standard one.
        if ($this->profile != 'standard') {
            $this->drupalCreateContentType([
                'type' => 'article',
                'name' => 'Article',
            ]);
        }
        $admin_user = $this->drupalCreateUser([
            'administer content types',
        ]);
        $this->drupalLogin($admin_user);
        $edit = [
            'language_configuration[langcode]' => 'current_interface',
            'language_configuration[language_alterable]' => TRUE,
        ];
        $this->drupalGet('admin/structure/types/manage/article');
        $this->submitForm($edit, 'Save');
        // Check the language default configuration for the articles.
        $configuration = ContentLanguageSettings::loadByEntityTypeBundle('node', 'article');
        $uuid = $configuration->uuid();
        $this->assertEquals('current_interface', $configuration->getDefaultLangcode(), 'The default language configuration has been saved on the Article content type.');
        $this->assertTrue($configuration->isLanguageAlterable(), 'The alterable language configuration has been saved on the Article content type.');
        // Update the article content type by changing the title label.
        $edit = [
            'title_label' => 'Name',
        ];
        $this->drupalGet('admin/structure/types/manage/article');
        $this->submitForm($edit, 'Save');
        // Check that we still have the settings for the updated node type.
        $configuration = ContentLanguageSettings::loadByEntityTypeBundle('node', 'article');
        $this->assertEquals('current_interface', $configuration->getDefaultLangcode(), 'The default language configuration has been kept on the updated Article content type.');
        $this->assertTrue($configuration->isLanguageAlterable(), 'The alterable language configuration has been kept on the updated Article content type.');
        $this->assertEquals($uuid, $configuration->uuid(), 'The language configuration uuid has been kept on the updated Article content type.');
    }
    
    /**
     * Tests the language settings are deleted on bundle delete.
     */
    public function testNodeTypeDelete() : void {
        // Create the article content type first if the profile used is not the
        // standard one.
        if ($this->profile != 'standard') {
            $this->drupalCreateContentType([
                'type' => 'article',
                'name' => 'Article',
            ]);
        }
        $admin_user = $this->drupalCreateUser([
            'administer content types',
        ]);
        $this->drupalLogin($admin_user);
        // Create language configuration for the articles.
        $edit = [
            'language_configuration[langcode]' => 'authors_default',
            'language_configuration[language_alterable]' => TRUE,
        ];
        $this->drupalGet('admin/structure/types/manage/article');
        $this->submitForm($edit, 'Save');
        // Check the language default configuration for articles is present.
        $configuration = \Drupal::entityTypeManager()->getStorage('language_content_settings')
            ->load('node.article');
        $this->assertNotEmpty($configuration, 'The language configuration is present.');
        // Delete 'article' bundle.
        $this->drupalGet('admin/structure/types/manage/article/delete');
        $this->submitForm([], 'Delete');
        // Check that the language configuration has been deleted.
        \Drupal::entityTypeManager()->getStorage('language_content_settings')
            ->resetCache();
        $configuration = \Drupal::entityTypeManager()->getStorage('language_content_settings')
            ->load('node.article');
        $this->assertNull($configuration, 'The language configuration was deleted after bundle was deleted.');
    }
    
    /**
     * Tests that the configuration is retained when a vocabulary is updated.
     */
    public function testTaxonomyVocabularyUpdate() : void {
        $vocabulary = Vocabulary::create([
            'name' => 'Country',
            'vid' => 'country',
        ]);
        $vocabulary->save();
        $admin_user = $this->drupalCreateUser([
            'administer taxonomy',
        ]);
        $this->drupalLogin($admin_user);
        $edit = [
            'default_language[langcode]' => 'current_interface',
            'default_language[language_alterable]' => TRUE,
        ];
        $this->drupalGet('admin/structure/taxonomy/manage/country');
        $this->submitForm($edit, 'Save');
        // Check the language default configuration.
        $configuration = ContentLanguageSettings::loadByEntityTypeBundle('taxonomy_term', 'country');
        $uuid = $configuration->uuid();
        $this->assertEquals('current_interface', $configuration->getDefaultLangcode(), 'The default language configuration has been saved on the Country vocabulary.');
        $this->assertTrue($configuration->isLanguageAlterable(), 'The alterable language configuration has been saved on the Country vocabulary.');
        // Update the vocabulary.
        $edit = [
            'name' => 'Nation',
        ];
        $this->drupalGet('admin/structure/taxonomy/manage/country');
        $this->submitForm($edit, 'Save');
        // Check that we still have the settings for the updated vocabulary.
        $configuration = ContentLanguageSettings::loadByEntityTypeBundle('taxonomy_term', 'country');
        $this->assertEquals('current_interface', $configuration->getDefaultLangcode(), 'The default language configuration has been kept on the updated Country vocabulary.');
        $this->assertTrue($configuration->isLanguageAlterable(), 'The alterable language configuration has been kept on the updated Country vocabulary.');
        $this->assertEquals($uuid, $configuration->uuid(), 'The language configuration uuid has been kept on the updated Country vocabulary.');
    }

}