<?php

declare(strict_types=1);

namespace Drupal\KernelTests\Core\Config;

use Drupal\Component\Utility\NestedArray;
use Drupal\Core\Config\Entity\ConfigEntityInterface;
use Drupal\Core\Config\Schema\Mapping;
use Drupal\Core\Config\TypedConfigManagerInterface;
use Drupal\Core\Entity\EntityWithPluginCollectionInterface;
use Drupal\Core\Entity\Plugin\DataType\ConfigEntityAdapter;
use Drupal\Core\Language\LanguageInterface;
use Drupal\Core\Language\LanguageManager;
use Drupal\Core\TypedData\Plugin\DataType\LanguageReference;
use Drupal\Core\TypedData\TypedDataInterface;
use Drupal\Core\Validation\Plugin\Validation\Constraint\FullyValidatableConstraint;
use Drupal\KernelTests\KernelTestBase;
use Drupal\language\Entity\ConfigurableLanguage;

// cspell:ignore kthxbai

/**
 * Base class for testing validation of config entities.
 *
 * @group config
 * @group Validation
 */
abstract class ConfigEntityValidationTestBase extends KernelTestBase {

  /**
   * {@inheritdoc}
   */
  protected static $modules = ['system'];

  /**
   * The config entity being tested.
   *
   * @var \Drupal\Core\Config\Entity\ConfigEntityInterface
   */
  protected ConfigEntityInterface $entity;

  /**
   * Whether a config entity of this type has a label.
   *
   * Most config entity types ensure their entities have a label. But a few do
   * not, typically highly abstract/very low level config entities without a
   * strong UI presence. For example: REST resource configuration entities and
   * entity view displays.
   *
   * @see \Drupal\Core\Entity\EntityInterface::label()
   *
   * @var bool
   */
  protected bool $hasLabel = TRUE;

  /**
   * The config entity mapping properties with >=1 required keys.
   *
   * All top-level properties of a config entity are guaranteed to be defined
   * (since they are defined as properties on the corresponding PHP class). That
   * is why they can never trigger "required key" validation errors. Only for
   * non-top-level properties can such validation errors be triggered, and hence
   * that is only possible on top-level properties of `type: mapping`.
   *
   * @var string[]
   * @see \Drupal\Core\Config\Entity\ConfigEntityType::getPropertiesToExport()
   * @see ::testRequiredPropertyKeysMissing()
   * @see \Drupal\Core\Validation\Plugin\Validation\Constraint\ValidKeysConstraintValidator
   */
  protected static array $propertiesWithRequiredKeys = [];

  /**
   * The config entity properties whose values are optional (set to NULL).
   *
   * @var string[]
   * @see \Drupal\Core\Config\Entity\ConfigEntityTypeInterface::getPropertiesToExport()
   * @see ::testRequiredPropertyValuesMissing()
   */
  protected static array $propertiesWithOptionalValues = [
    '_core',
    'third_party_settings',
  ];

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();
    $this->installConfig('system');

    // Install Stark so we can add a legitimately installed theme to config
    // dependencies.
    $this->container->get('theme_installer')->install(['stark']);
    $this->container = $this->container->get('kernel')->getContainer();
  }

  /**
   * Ensures that the entity created in ::setUp() has no validation errors.
   */
  public function testEntityIsValid(): void {
    $this->assertInstanceOf(ConfigEntityInterface::class, $this->entity);
    $this->assertValidationErrors([]);
  }

  /**
   * Returns the validation constraints applied to the entity's ID.
   *
   * If the entity type does not define an ID key, the test will fail. If an ID
   * key is defined but is not using the `machine_name` data type, the test will
   * be skipped.
   *
   * @return array[]
   *   The validation constraint configuration applied to the entity's ID.
   */
  protected function getMachineNameConstraints(): array {
    $id_key = $this->entity->getEntityType()->getKey('id');
    $this->assertNotEmpty($id_key, "The entity under test does not define an ID key.");

    $data_definition = $this->entity->getTypedData()
      ->get($id_key)
      ->getDataDefinition();
    if ($data_definition->getDataType() === 'machine_name') {
      return $data_definition->getConstraints();
    }
    else {
      $this->markTestSkipped("The entity's ID key does not use the machine_name data type.");
    }
  }

  /**
   * Data provider for ::testInvalidMachineNameCharacters().
   *
   * @return array[]
   *   The test cases.
   */
  public static function providerInvalidMachineNameCharacters(): array {
    return [
      'INVALID: space separated' => ['space separated', FALSE],
      'INVALID: dash separated' => ['dash-separated', FALSE],
      'INVALID: uppercase letters' => ['Uppercase_Letters', FALSE],
      'INVALID: period separated' => ['period.separated', FALSE],
      'VALID: underscore separated' => ['underscore_separated', TRUE],
    ];
  }

  /**
   * Tests that the entity's ID is tested for invalid characters.
   *
   * @param string $machine_name
   *   A machine name to test.
   * @param bool $is_expected_to_be_valid
   *   Whether this machine name is expected to be considered valid.
   *
   * @dataProvider providerInvalidMachineNameCharacters
   */
  public function testInvalidMachineNameCharacters(string $machine_name, bool $is_expected_to_be_valid): void {
    $constraints = $this->getMachineNameConstraints();

    $this->assertNotEmpty($constraints['Regex']);
    $this->assertIsArray($constraints['Regex']);
    $this->assertArrayHasKey('pattern', $constraints['Regex']);
    $this->assertIsString($constraints['Regex']['pattern']);
    $this->assertArrayHasKey('message', $constraints['Regex']);
    $this->assertIsString($constraints['Regex']['message']);

    $id_key = $this->entity->getEntityType()->getKey('id');
    if ($is_expected_to_be_valid) {
      $expected_errors = [];
    }
    else {
      $expected_errors = [$id_key => sprintf('The <em class="placeholder">&quot;%s&quot;</em> machine name is not valid.', $machine_name)];
    }

    // Config entity IDs are immutable by default.
    $expected_errors[''] = "The '$id_key' property cannot be changed.";

    $this->entity->set($id_key, $machine_name);
    $this->assertValidationErrors($expected_errors);
  }

  /**
   * Tests that the entity ID's length is validated if it is a machine name.
   */
  public function testMachineNameLength(): void {
    $constraints = $this->getMachineNameConstraints();

    $max_length = $constraints['Length']['max'];
    $this->assertIsInt($max_length);
    $this->assertGreaterThan(0, $max_length);

    $id_key = $this->entity->getEntityType()->getKey('id');
    $expected_errors = [
      $id_key => 'This value is too long. It should have <em class="placeholder">' . $max_length . '</em> characters or less.',
      // Config entity IDs are immutable by default.
      '' => "The '$id_key' property cannot be changed.",
    ];
    $this->entity->set($id_key, $this->randomMachineName($max_length + 2));
    $this->assertValidationErrors($expected_errors);
  }

  /**
   * Data provider for ::testConfigDependenciesValidation().
   *
   * @return array[]
   *   The test cases.
   */
  public static function providerConfigDependenciesValidation(): array {
    return [
      'valid dependency types' => [
        [
          'config' => ['system.site'],
          'content' => ['node:some-random-uuid'],
          'module' => ['system'],
          'theme' => ['stark'],
        ],
        [],
      ],
      'unknown dependency type' => [
        [
          'fun_stuff' => ['star-trek.deep-space-nine'],
        ],
        [
          'dependencies.fun_stuff' => "'fun_stuff' is not a supported key.",
        ],
      ],
      'empty string in config dependencies' => [
        [
          'config' => [''],
        ],
        [
          'dependencies.config.0' => [
            'This value should not be blank.',
            "The '' config does not exist.",
          ],
        ],
      ],
      'non-existent config dependency' => [
        [
          'config' => ['fake_settings'],
        ],
        [
          'dependencies.config.0' => "The 'fake_settings' config does not exist.",
        ],
      ],
      'empty string in module dependencies' => [
        [
          'module' => [''],
        ],
        [
          'dependencies.module.0' => [
            'This value should not be blank.',
            "Module '' is not installed.",
          ],
        ],
      ],
      'invalid module dependency' => [
        [
          'module' => ['invalid-module-name'],
        ],
        [
          'dependencies.module.0' => [
            'This value is not valid.',
            "Module 'invalid-module-name' is not installed.",
          ],
        ],
      ],
      'non-installed module dependency' => [
        [
          'module' => ['bad_judgment'],
        ],
        [
          'dependencies.module.0' => "Module 'bad_judgment' is not installed.",
        ],
      ],
      'empty string in theme dependencies' => [
        [
          'theme' => [''],
        ],
        [
          'dependencies.theme.0' => [
            'This value should not be blank.',
            "Theme '' is not installed.",
          ],
        ],
      ],
      'invalid theme dependency' => [
        [
          'theme' => ['invalid-theme-name'],
        ],
        [
          'dependencies.theme.0' => [
            'This value is not valid.',
            "Theme 'invalid-theme-name' is not installed.",
          ],
        ],
      ],
      'non-installed theme dependency' => [
        [
          'theme' => ['ugly_theme'],
        ],
        [
          'dependencies.theme.0' => "Theme 'ugly_theme' is not installed.",
        ],
      ],
    ];
  }

  /**
   * Tests validation of config dependencies.
   *
   * @param array[] $dependencies
   *   The dependencies that should be added to the config entity under test.
   * @param array<string, string|string[]> $expected_messages
   *   The expected validation error messages. Keys are property paths, values
   *   are the expected messages: a string if a single message is expected, an
   *   array of strings if multiple are expected.
   *
   * @dataProvider providerConfigDependenciesValidation
   */
  public function testConfigDependenciesValidation(array $dependencies, array $expected_messages): void {
    // Add the dependencies we were given to the dependencies that may already
    // exist in the entity.
    $dependencies = NestedArray::mergeDeep($dependencies, $this->entity->getDependencies());

    $this->entity->set('dependencies', $dependencies);
    $this->assertValidationErrors($expected_messages);

    // Enforce these dependencies, and ensure we get the same results.
    $this->entity->set('dependencies', [
      'enforced' => $dependencies,
    ]);
    // We now expect validation errors not at `dependencies.module.0`, but at
    // `dependencies.enforced.module.0`. So reuse the same messages, but perform
    // string replacement in the keys.
    $expected_enforced_messages = array_combine(
      str_replace('dependencies', 'dependencies.enforced', array_keys($expected_messages)),
      array_values($expected_messages),
    );
    $this->assertValidationErrors($expected_enforced_messages);
  }

  /**
   * Tests validation of config entity's label.
   *
   * @see \Drupal\Core\Entity\EntityInterface::label()
   * @see \Drupal\Core\Entity\EntityBase::label()
   */
  public function testLabelValidation(): void {
    // Some entity types do not have a label.
    if (!$this->hasLabel) {
      $this->markTestSkipped();
    }
    if ($this->entity->getEntityType()->getKey('label') === $this->entity->getEntityType()->getKey('id')) {
      $this->markTestSkipped('This entity type uses the ID as the label; an entity without a label is hence impossible.');
    }

    static::setLabel($this->entity, "Multi\nLine");
    $this->assertValidationErrors([$this->entity->getEntityType()->getKey('label') => "Labels are not allowed to span multiple lines or contain control characters."]);
  }

  /**
   * Sets the label of the given config entity.
   *
   * @param \Drupal\Core\Config\Entity\ConfigEntityInterface $entity
   *   The config entity to modify.
   * @param string $label
   *   The label to set.
   *
   * @see ::testLabelValidation()
   */
  protected static function setLabel(ConfigEntityInterface $entity, string $label): void {
    $label_property = $entity->getEntityType()->getKey('label');
    if ($label_property === FALSE) {
      throw new \LogicException(sprintf('Override %s to allow testing a %s without a label.', __METHOD__, (string) $entity->getEntityType()->getSingularLabel()));
    }

    $entity->set($label_property, $label);
  }

  /**
   * Asserts a set of validation errors is raised when the entity is validated.
   *
   * @param array<string, string|string[]> $expected_messages
   *   The expected validation error messages. Keys are property paths, values
   *   are the expected messages: a string if a single message is expected, an
   *   array of strings if multiple are expected.
   */
  protected function assertValidationErrors(array $expected_messages): void {
    /** @var \Drupal\Core\TypedData\TypedDataManagerInterface $typed_data */
    $typed_data = $this->container->get('typed_data_manager');
    $definition = $typed_data->createDataDefinition('entity:' . $this->entity->getEntityTypeId());
    $violations = $typed_data->create($definition, $this->entity)->validate();

    $actual_messages = [];
    foreach ($violations as $violation) {
      $property_path = $violation->getPropertyPath();

      if (!isset($actual_messages[$property_path])) {
        $actual_messages[$property_path] = (string) $violation->getMessage();
      }
      else {
        // Transform value from string to array.
        if (is_string($actual_messages[$property_path])) {
          $actual_messages[$property_path] = (array) $actual_messages[$violation->getPropertyPath()];
        }
        // And append.
        $actual_messages[$property_path][] = (string) $violation->getMessage();
      }
    }
    ksort($expected_messages);
    ksort($actual_messages);
    $this->assertSame($expected_messages, $actual_messages);
  }

  /**
   * Tests that the config entity's langcode is validated.
   */
  public function testLangcode(): void {
    $this->entity->set('langcode', NULL);
    $this->assertValidationErrors([
      'langcode' => 'This value should not be null.',
    ]);

    // A langcode from the standard list should always be acceptable.
    $standard_languages = LanguageManager::getStandardLanguageList();
    $this->assertNotEmpty($standard_languages);
    $this->entity->set('langcode', key($standard_languages));
    $this->assertValidationErrors([]);

    // All special, internal langcodes should be acceptable.
    $system_langcodes = [
      LanguageInterface::LANGCODE_NOT_SPECIFIED,
      LanguageInterface::LANGCODE_NOT_APPLICABLE,
      LanguageInterface::LANGCODE_DEFAULT,
      LanguageInterface::LANGCODE_SITE_DEFAULT,
      LanguageInterface::LANGCODE_SYSTEM,
    ];
    foreach ($system_langcodes as $langcode) {
      $this->entity->set('langcode', $langcode);
      $this->assertValidationErrors([]);
    }

    // An invalid langcode should be unacceptable, even if it "looks" right.
    $fake_langcode = 'definitely-not-a-language';
    $this->assertArrayNotHasKey($fake_langcode, LanguageReference::getAllValidLangcodes());
    $this->entity->set('langcode', $fake_langcode);
    $this->assertValidationErrors([
      'langcode' => 'The value you selected is not a valid choice.',
    ]);

    // If a new configurable language is created with a non-standard langcode,
    // it should be acceptable.
    $this->enableModules(['language']);
    // The language doesn't exist yet, so it shouldn't be a valid choice.
    $this->entity->set('langcode', 'kthxbai');
    $this->assertValidationErrors([
      'langcode' => 'The value you selected is not a valid choice.',
    ]);
    // Once we create the language, it should be a valid choice.
    ConfigurableLanguage::createFromLangcode('kthxbai')->save();
    $this->assertValidationErrors([]);
  }

  /**
   * Tests that immutable properties cannot be changed.
   *
   * @param mixed[] $valid_values
   *   (optional) The values to set for the immutable properties, keyed by name.
   *   This should be used if the immutable properties can only accept certain
   *   values, e.g. valid plugin IDs.
   */
  public function testImmutableProperties(array $valid_values = []): void {
    $constraints = $this->entity->getEntityType()->getConstraints();
    $this->assertNotEmpty($constraints['ImmutableProperties'], 'All config entities should have at least one immutable ID property.');

    foreach ($constraints['ImmutableProperties'] as $property_name) {
      $original_value = $this->entity->get($property_name);
      $this->entity->set($property_name, $valid_values[$property_name] ?? $this->randomMachineName());
      $this->assertValidationErrors([
        '' => "The '$property_name' property cannot be changed.",
      ]);
      $this->entity->set($property_name, $original_value);
    }
  }

  /**
   * A property that is required must have a value (i.e. not NULL).
   *
   * @param string[]|null $additional_expected_validation_errors_when_missing
   *   Some required config entity properties have additional validation
   *   constraints that cause additional messages to appear. Keys must be
   *   config entity properties, values must be arrays as expected by
   *   ::assertValidationErrors().
   *
   * @todo Remove this optional parameter in https://www.drupal.org/project/drupal/issues/2820364#comment-15333069
   *
   * @return void
   */
  public function testRequiredPropertyKeysMissing(?array $additional_expected_validation_errors_when_missing = NULL): void {
    $config_entity_properties = array_keys($this->entity->getEntityType()->getPropertiesToExport());

    if (!empty(array_diff(array_keys($additional_expected_validation_errors_when_missing ?? []), $config_entity_properties))) {
      throw new \LogicException(sprintf('The test %s lists `%s` in $additional_expected_validation_errors_when_missing but it is not a property of the `%s` config entity type.',
        get_called_class(),
        implode(', ', array_diff(array_keys($additional_expected_validation_errors_when_missing), $config_entity_properties)),
        $this->entity->getEntityTypeId(),
      ));
    }

    $mapping_properties = array_keys(array_filter(
      ConfigEntityAdapter::createFromEntity($this->entity)->getProperties(FALSE),
      fn (TypedDataInterface $v) => $v instanceof Mapping
    ));

    $required_property_keys = $this->getRequiredPropertyKeys();
    if (!$this->isFullyValidatable()) {
      $this->assertEmpty($required_property_keys, 'No keys can be required when a config entity type is not fully validatable.');
    }

    $original_entity = clone $this->entity;
    foreach ($mapping_properties as $property) {
      $this->entity = clone $original_entity;
      $this->entity->set($property, []);
      $expected_validation_errors = array_key_exists($property, $required_property_keys)
        ? [$property => $required_property_keys[$property]]
        : [];
      $this->assertValidationErrors(($additional_expected_validation_errors_when_missing[$property] ?? []) + $expected_validation_errors);
    }
  }

  /**
   * A property that is required must have a value (i.e. not NULL).
   *
   * @param string[]|null $additional_expected_validation_errors_when_missing
   *   Some required config entity properties have additional validation
   *   constraints that cause additional messages to appear. Keys must be
   *   config entity properties, values must be arrays as expected by
   *   ::assertValidationErrors().
   *
   * @todo Remove this optional parameter in https://www.drupal.org/project/drupal/issues/2820364#comment-15333069
   *
   * @return void
   */
  public function testRequiredPropertyValuesMissing(?array $additional_expected_validation_errors_when_missing = NULL): void {
    $config_entity_properties = array_keys($this->entity->getEntityType()->getPropertiesToExport());

    // Guide developers when $additional_expected_validation_errors_when_missing
    // does not contain sensible values.
    $non_existing_properties = array_diff(array_keys($additional_expected_validation_errors_when_missing ?? []), $config_entity_properties);
    if ($non_existing_properties) {
      throw new \LogicException(sprintf('The test %s lists `%s` in $additional_expected_validation_errors_when_missing but it is not a property of the `%s` config entity type.',
        __METHOD__,
        implode(', ', $non_existing_properties),
        $this->entity->getEntityTypeId(),
      ));
    }
    $properties_with_optional_values = $this->getPropertiesWithOptionalValues();

    // Get the config entity properties that are immutable.
    // @see ::testImmutableProperties()
    $immutable_properties = $this->entity->getEntityType()->getConstraints()['ImmutableProperties'];

    // Config entity properties containing plugin collections are special cases:
    // setting them to NULL would cause them to get out of sync with the plugin
    // collection.
    // @see \Drupal\Core\Config\Entity\ConfigEntityBase::set()
    // @see \Drupal\Core\Config\Entity\ConfigEntityBase::preSave()
    $plugin_collection_properties = $this->entity instanceof EntityWithPluginCollectionInterface
      ? array_keys($this->entity->getPluginCollections())
      : [];

    // To test properties with missing required values, $this->entity must be
    // modified to be able to use ::assertValidationErrors(). To allow restoring
    // $this->entity to its original value for each tested property, a clone of
    // the original entity is needed.
    $original_entity = clone $this->entity;
    foreach ($config_entity_properties as $property) {
      // Do not try to set immutable properties to NULL: their immutability is
      // already tested.
      // @see ::testImmutableProperties()
      if (in_array($property, $immutable_properties, TRUE)) {
        continue;
      }

      // Do not try to set plugin collection properties to NULL.
      if (in_array($property, $plugin_collection_properties, TRUE)) {
        continue;
      }

      $this->entity = clone $original_entity;
      $this->entity->set($property, NULL);
      $expected_validation_errors = in_array($property, $properties_with_optional_values, TRUE)
        ? []
        : [$property => 'This value should not be null.'];

      // @see `type: required_label`
      // @see \Symfony\Component\Validator\Constraints\NotBlank
      if (!$this->isFullyValidatable() && $this->entity->getEntityType()->getKey('label') == $property) {
        $expected_validation_errors = [$property => 'This value should not be blank.'];
      }

      $this->assertValidationErrors(($additional_expected_validation_errors_when_missing[$property] ?? []) + $expected_validation_errors);
    }
  }

  /**
   * Whether the tested config entity type is fully validatable.
   *
   * @return bool
   *   Whether the tested config entity type is fully validatable.
   */
  protected function isFullyValidatable(): bool {
    $typed_config = $this->container->get('config.typed');
    assert($typed_config instanceof TypedConfigManagerInterface);
    // @see \Drupal\Core\Entity\Plugin\DataType\ConfigEntityAdapter::getConfigTypedData()
    $config_entity_type_schema_constraints = $typed_config
      ->createFromNameAndData(
        $this->entity->getConfigDependencyName(),
        $this->entity->toArray()
      )->getConstraints();

    foreach ($config_entity_type_schema_constraints as $constraint) {
      if ($constraint instanceof FullyValidatableConstraint) {
        return TRUE;
      }
    }
    return FALSE;
  }

  /**
   * Determines the config entity mapping properties with required keys.
   *
   * This refers only to the top-level properties of the config entity which are expected to be mappings, and of those mappings, only the ones which have required keys.
   *
   * @return string[]
   *   An array of key-value pairs, with:
   *   - keys: names of the config entity properties which are mappings that
   *     contain required keys.
   *   - values: the corresponding expected validation error message.
   */
  protected function getRequiredPropertyKeys(): array {
    // If a config entity type is not fully validatable, no mapping property
    // keys are required.
    if (!$this->isFullyValidatable()) {
      return [];
    }

    $config_entity_properties = array_keys($this->entity->getEntityType()
      ->getPropertiesToExport());

    // Otherwise, all mapping property keys are required except for those marked
    // optional. Rather than inspecting config schema, require authors of tests
    // to explicitly list optional properties in a `propertiesWithRequiredKeys`
    // property on this class.
    // @see \Drupal\KernelTests\Config\Schema\MappingTest::testMappingInterpretation()
    $class = static::class;
    $properties_with_required_keys = [];
    while ($class) {
      if (property_exists($class, 'propertiesWithRequiredKeys')) {
        $properties_with_required_keys += $class::$propertiesWithRequiredKeys;
      }
      $class = get_parent_class($class);
    }

    // Guide developers when $propertiesWithRequiredKeys does not contain
    // sensible values.
    if (!empty(array_diff(array_keys($properties_with_required_keys), $config_entity_properties))) {
      throw new \LogicException(sprintf('The %s test class lists %s in $propertiesWithRequiredKeys but it is not a property of the %s config entity type.',
        get_called_class(),
        implode(', ', array_diff(array_keys($properties_with_required_keys), $config_entity_properties)),
        $this->entity->getEntityTypeId()
      ));
    }

    return $properties_with_required_keys;
  }

  /**
   * Determines the config entity properties with optional values.
   *
   * @return string[]
   *   The config entity properties whose values are optional.
   */
  protected function getPropertiesWithOptionalValues(): array {
    $config_entity_properties = array_keys($this->entity->getEntityType()
      ->getPropertiesToExport());

    // If a config entity type is not fully validatable, all properties are
    // optional, with the exception of `type: langcode` and
    // `type: required_label`.
    if (!$this->isFullyValidatable()) {
      return array_diff($config_entity_properties, [
        // @see `type: langcode`
        // @see \Symfony\Component\Validator\Constraints\NotNull
        'langcode',
        'default_langcode',
        // @see `type: required_label`
        // @see \Symfony\Component\Validator\Constraints\NotBlank
        $this->entity->getEntityType()->getKey('label'),
      ]);
    }

    // Otherwise, all properties are required except for those marked
    // optional. Rather than inspecting config schema, require authors of tests
    // to explicitly list optional properties in a
    // `propertiesWithOptionalValues` property on this class.
    $class = static::class;
    $optional_properties = [];
    while ($class) {
      if (property_exists($class, 'propertiesWithOptionalValues')) {
        $optional_properties = array_merge($optional_properties, $class::$propertiesWithOptionalValues);
      }
      $class = get_parent_class($class);
    }
    $optional_properties = array_unique($optional_properties);

    // Guide developers when $optionalProperties does not contain sensible
    // values.
    $non_existing_properties = array_diff($optional_properties, $config_entity_properties);
    if ($non_existing_properties) {
      throw new \LogicException(sprintf('The %s test class lists %s in $optionalProperties but it is not a property of the %s config entity type.',
        static::class,
        implode(', ', $non_existing_properties),
        $this->entity->getEntityTypeId()
      ));
    }

    return $optional_properties;
  }

}
