class UnitTestCase

abstract class UnitTestCase extends TestCase {
    use PhpunitCompatibilityTrait;
    
    /**
     * The random generator.
     *
     * @var \Drupal\Component\Utility\Random
     */
    protected $randomGenerator;
    
    /**
     * The app root.
     *
     * @var string
     */
    protected $root;
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() {
        parent::setUp();
        // Ensure that an instantiated container in the global state of \Drupal from
        // a previous test does not leak into this test.
        \Drupal::unsetContainer();
        // Ensure that the NullFileCache implementation is used for the FileCache as
        // unit tests should not be relying on caches implicitly.
        FileCacheFactory::setConfiguration([
            FileCacheFactory::DISABLE_CACHE => TRUE,
        ]);
        // Ensure that FileCacheFactory has a prefix.
        FileCacheFactory::setPrefix('prefix');
        $this->root = dirname(dirname(substr(__DIR__, 0, -strlen(__NAMESPACE__))));
    }
    
    /**
     * Generates a unique random string containing letters and numbers.
     *
     * @param int $length
     *   Length of random string to generate.
     *
     * @return string
     *   Randomly generated unique string.
     *
     * @see \Drupal\Component\Utility\Random::name()
     */
    public function randomMachineName($length = 8) {
        return $this->getRandomGenerator()
            ->name($length, TRUE);
    }
    
    /**
     * Gets the random generator for the utility methods.
     *
     * @return \Drupal\Component\Utility\Random
     *   The random generator
     */
    protected function getRandomGenerator() {
        if (!is_object($this->randomGenerator)) {
            $this->randomGenerator = new Random();
        }
        return $this->randomGenerator;
    }
    
    /**
     * Asserts if two arrays are equal by sorting them first.
     *
     * @param array $expected
     * @param array $actual
     * @param string $message
     */
    protected function assertArrayEquals(array $expected, array $actual, $message = NULL) {
        ksort($expected);
        ksort($actual);
        $this->assertEquals($expected, $actual, !empty($message) ? $message : '');
    }
    
    /**
     * Returns a stub config factory that behaves according to the passed array.
     *
     * Use this to generate a config factory that will return the desired values
     * for the given config names.
     *
     * @param array $configs
     *   An associative array of configuration settings whose keys are
     *   configuration object names and whose values are key => value arrays for
     *   the configuration object in question. Defaults to an empty array.
     *
     * @return \PHPUnit\Framework\MockObject\MockBuilder
     *   A MockBuilder object for the ConfigFactory with the desired return
     *   values.
     */
    public function getConfigFactoryStub(array $configs = []) {
        $config_get_map = [];
        $config_editable_map = [];
        // Construct the desired configuration object stubs, each with its own
        // desired return map.
        foreach ($configs as $config_name => $config_values) {
            // Define a closure over the $config_values, which will be used as a
            // returnCallback below. This function will mimic
            // \Drupal\Core\Config\Config::get and allow using dotted keys.
            $config_get = function ($key = '') use ($config_values) {
                // Allow to pass in no argument.
                if (empty($key)) {
                    return $config_values;
                }
                // See if we have the key as is.
                if (isset($config_values[$key])) {
                    return $config_values[$key];
                }
                $parts = explode('.', $key);
                $value = NestedArray::getValue($config_values, $parts, $key_exists);
                return $key_exists ? $value : NULL;
            };
            $immutable_config_object = $this->getMockBuilder('Drupal\\Core\\Config\\ImmutableConfig')
                ->disableOriginalConstructor()
                ->getMock();
            $immutable_config_object->expects($this->any())
                ->method('get')
                ->will($this->returnCallback($config_get));
            $config_get_map[] = [
                $config_name,
                $immutable_config_object,
            ];
            $mutable_config_object = $this->getMockBuilder('Drupal\\Core\\Config\\Config')
                ->disableOriginalConstructor()
                ->getMock();
            $mutable_config_object->expects($this->any())
                ->method('get')
                ->will($this->returnCallback($config_get));
            $config_editable_map[] = [
                $config_name,
                $mutable_config_object,
            ];
        }
        // Construct a config factory with the array of configuration object stubs
        // as its return map.
        $config_factory = $this->createMock('Drupal\\Core\\Config\\ConfigFactoryInterface');
        $config_factory->expects($this->any())
            ->method('get')
            ->will($this->returnValueMap($config_get_map));
        $config_factory->expects($this->any())
            ->method('getEditable')
            ->will($this->returnValueMap($config_editable_map));
        return $config_factory;
    }
    
    /**
     * Returns a stub config storage that returns the supplied configuration.
     *
     * @param array $configs
     *   An associative array of configuration settings whose keys are
     *   configuration object names and whose values are key => value arrays
     *   for the configuration object in question.
     *
     * @return \Drupal\Core\Config\StorageInterface
     *   A mocked config storage.
     */
    public function getConfigStorageStub(array $configs) {
        $config_storage = $this->createMock('Drupal\\Core\\Config\\NullStorage');
        $config_storage->expects($this->any())
            ->method('listAll')
            ->will($this->returnValue(array_keys($configs)));
        foreach ($configs as $name => $config) {
            $config_storage->expects($this->any())
                ->method('read')
                ->with($this->equalTo($name))
                ->will($this->returnValue($config));
        }
        return $config_storage;
    }
    
    /**
     * Mocks a block with a block plugin.
     *
     * @param string $machine_name
     *   The machine name of the block plugin.
     *
     * @return \Drupal\block\BlockInterface|\PHPUnit\Framework\MockObject\MockObject
     *   The mocked block.
     *
     * @deprecated in drupal:8.5.0 and is removed from drupal:9.0.0. Unit test
     *   base classes should not have dependencies on extensions. Set up mocks in
     *   individual tests.
     *
     * @see https://www.drupal.org/node/2896072
     */
    protected function getBlockMockWithMachineName($machine_name) {
        $plugin = $this->getMockBuilder('Drupal\\Core\\Block\\BlockBase')
            ->disableOriginalConstructor()
            ->getMock();
        $plugin->expects($this->any())
            ->method('getMachineNameSuggestion')
            ->will($this->returnValue($machine_name));
        $block = $this->getMockBuilder('Drupal\\block\\Entity\\Block')
            ->disableOriginalConstructor()
            ->getMock();
        $block->expects($this->any())
            ->method('getPlugin')
            ->will($this->returnValue($plugin));
        @trigger_error(__METHOD__ . ' is deprecated in Drupal 8.5.x, will be removed before Drupal 9.0.0. Unit test base classes should not have dependencies on extensions. Set up mocks in individual tests.', E_USER_DEPRECATED);
        return $block;
    }
    
    /**
     * Returns a stub translation manager that just returns the passed string.
     *
     * @return \PHPUnit\Framework\MockObject\MockObject|\Drupal\Core\StringTranslation\TranslationInterface
     *   A mock translation object.
     */
    public function getStringTranslationStub() {
        $translation = $this->createMock('Drupal\\Core\\StringTranslation\\TranslationInterface');
        $translation->expects($this->any())
            ->method('translate')
            ->willReturnCallback(function ($string, array $args = [], array $options = []) use ($translation) {
            return new TranslatableMarkup($string, $args, $options, $translation);
        });
        $translation->expects($this->any())
            ->method('translateString')
            ->willReturnCallback(function (TranslatableMarkup $wrapper) {
            return $wrapper->getUntranslatedString();
        });
        $translation->expects($this->any())
            ->method('formatPlural')
            ->willReturnCallback(function ($count, $singular, $plural, array $args = [], array $options = []) use ($translation) {
            $wrapper = new PluralTranslatableMarkup($count, $singular, $plural, $args, $options, $translation);
            return $wrapper;
        });
        return $translation;
    }
    
    /**
     * Sets up a container with a cache tags invalidator.
     *
     * @param \Drupal\Core\Cache\CacheTagsInvalidatorInterface $cache_tags_validator
     *   The cache tags invalidator.
     *
     * @return \Symfony\Component\DependencyInjection\ContainerInterface|\PHPUnit\Framework\MockObject\MockObject
     *   The container with the cache tags invalidator service.
     */
    protected function getContainerWithCacheTagsInvalidator(CacheTagsInvalidatorInterface $cache_tags_validator) {
        $container = $this->createMock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
        $container->expects($this->any())
            ->method('get')
            ->with('cache_tags.invalidator')
            ->will($this->returnValue($cache_tags_validator));
        \Drupal::setContainer($container);
        return $container;
    }
    
    /**
     * Returns a stub class resolver.
     *
     * @return \Drupal\Core\DependencyInjection\ClassResolverInterface|\PHPUnit\Framework\MockObject\MockObject
     *   The class resolver stub.
     */
    protected function getClassResolverStub() {
        $class_resolver = $this->createMock('Drupal\\Core\\DependencyInjection\\ClassResolverInterface');
        $class_resolver->expects($this->any())
            ->method('getInstanceFromDefinition')
            ->will($this->returnCallback(function ($class) {
            if (is_subclass_of($class, 'Drupal\\Core\\DependencyInjection\\ContainerInjectionInterface')) {
                return $class::create(new ContainerBuilder());
            }
            else {
                return new $class();
            }
        }));
        return $class_resolver;
    }

}