FieldTestHelper.php

<?php

declare (strict_types=1);
namespace Drupal\field_test;

use Drupal\Core\Entity\FieldableEntityInterface;
use Drupal\Core\Field\FieldDefinitionInterface;

/**
 * Helper class for testing fields.
 */
class FieldTestHelper {
    
    /**
     * Helper function to enable entity translations.
     */
    public static function entityInfoTranslatable($entity_type_id = NULL, $translatable = NULL) : array {
        static $stored_value = [];
        if (isset($entity_type_id)) {
            $entity_definition_update_manager = \Drupal::entityDefinitionUpdateManager();
            $entity_type = $entity_definition_update_manager->getEntityType($entity_type_id);
            $stored_value[$entity_type_id] = $translatable;
            if ($translatable != $entity_type->isTranslatable()) {
                $entity_definition_update_manager->uninstallEntityType($entity_type);
                $entity_type->set('translatable', $translatable);
                $entity_definition_update_manager->installEntityType($entity_type);
            }
        }
        return $stored_value;
    }
    
    /**
     * Sample 'default value' callback.
     */
    public static function defaultValue(FieldableEntityInterface $entity, FieldDefinitionInterface $definition) : array {
        return [
            [
                'value' => 99,
            ],
        ];
    }
    
    /**
     * Store and retrieve keyed data for later verification by unit tests.
     *
     * This function is a simple in-memory key-value store with the
     * distinction that it stores all values for a given key instead of
     * just the most recently set value. field_test module hooks call
     * this function to record their arguments, keyed by hook name. The
     * unit tests later call this function to verify that the correct
     * hooks were called and were passed the correct arguments.
     *
     * This function ignores all calls until the first time it is called
     * with $key of NULL. Each time it is called with $key of NULL, it
     * erases all previously stored data from its internal cache, but also
     * returns the previously stored data to the caller. A typical usage
     * scenario is:
     *
     * @code
     *   // calls to FieldTestHelper::memorize() here are ignored
     *
     *   // turn on memorization
     *   FieldTestHelper::memorize();
     *
     *   // call some Field API functions that invoke field_test hooks
     *   FieldStorageConfig::create($field_definition)->save();
     *
     *   // retrieve and reset the memorized hook call data
     *   $mem = FieldTestHelper::memorize();
     *
     *   // make sure hook_field_storage_config_create() is invoked correctly
     *   assertEquals(1, count($mem['fieldStorageConfigCreate']));
     *   assertEquals([$field], $mem['fieldStorageConfigCreate'][0]);
     * @endcode
     *
     * @param string $key
     *   The key under which to store to $value, or NULL as described above.
     * @param mixed|null $value
     *   A value to store for $key.
     *
     * @return array|null
     *   An array mapping each $key to an array of each $value passed in
     *   for that key.
     */
    public static function memorize($key = NULL, $value = NULL) : array|null {
        static $memorize;
        if (!isset($key)) {
            $return = $memorize;
            $memorize = [];
            return $return;
        }
        if (is_array($memorize)) {
            $memorize[$key][] = $value;
        }
        return NULL;
    }

}