");
+ }
+
+ return [];
+ }
+
+ public function isOptional(): bool
+ {
+ return false;
+ }
+}
diff --git a/src/DependencyInjection/Compiler/HTMLPurifierPass.php b/src/DependencyInjection/Compiler/HTMLPurifierPass.php
new file mode 100644
index 00000000..1008648a
--- /dev/null
+++ b/src/DependencyInjection/Compiler/HTMLPurifierPass.php
@@ -0,0 +1,53 @@
+hasAlias(HTMLPurifiersRegistryInterface::class)) {
+ return;
+ }
+
+ try {
+ $registry = $container->findDefinition(HTMLPurifiersRegistryInterface::class);
+ } catch (ServiceNotFoundException $e) {
+ return;
+ }
+
+ $purifiers = [];
+
+ foreach ($container->findTaggedServiceIds(self::PURIFIER_TAG) as $id => $tags) {
+ if (empty($tags[0]['profile'])) {
+ throw new InvalidConfigurationException(sprintf('Tag "%s" must define a "profile" attribute.', self::PURIFIER_TAG));
+ }
+
+ $profile = $tags[0]['profile'];
+ $purifier = $container->getDefinition($id);
+
+ if (empty($purifier->getArguments())) {
+ $configId = "exercise_html_purifier.config.$profile";
+ $config = $container->hasDefinition($configId) ? $configId : 'exercise_html_purifier.config.default';
+
+ $purifier->addArgument(new Reference($config));
+ }
+
+ $purifiers[$profile] = new Reference($id);
+ }
+
+ $registry->setArguments([
+ ServiceLocatorTagPass::register($container, $purifiers),
+ ]);
+ }
+}
diff --git a/src/DependencyInjection/Configuration.php b/src/DependencyInjection/Configuration.php
new file mode 100644
index 00000000..ec18707b
--- /dev/null
+++ b/src/DependencyInjection/Configuration.php
@@ -0,0 +1,98 @@
+getRootNode();
+
+ $rootNode
+ ->children()
+ ->scalarNode('default_cache_serializer_path')
+ ->defaultValue('%kernel.cache_dir%/htmlpurifier')
+ ->end()
+ ->scalarNode('default_cache_serializer_permissions')
+ // (format "%#o" 493) "0755"
+ ->defaultValue(493)
+ ->end()
+ ->arrayNode('html_profiles')
+ ->useAttributeAsKey('name')
+ ->normalizeKeys(false)
+ ->validate()
+ ->always(function ($profiles) {
+ foreach ($profiles as $profile => $definition) {
+ foreach ($definition['parents'] as $parent) {
+ if (!isset($profiles[$parent])) {
+ throw new InvalidConfigurationException(sprintf('Invalid parent "%s" is not defined for profile "%s".', $parent, $profile));
+ }
+ }
+ }
+
+ return $profiles;
+ })
+ ->end()
+ ->arrayPrototype()
+ ->children()
+ ->arrayNode('config')
+ ->defaultValue([])
+ ->info('An array of parameters.')
+ ->useAttributeAsKey('parameter')
+ ->normalizeKeys(false)
+ ->variablePrototype()->end()
+ ->end()
+ ->arrayNode('attributes')
+ ->defaultValue([])
+ ->info('Every key is a tag name, with arrays for rules')
+ ->normalizeKeys(false)
+ ->useAttributeAsKey('tag_name')
+ ->arrayPrototype()
+ ->info('Every key is an attribute name for a rule like "Text"')
+ ->useAttributeAsKey('attribute_name')
+ ->normalizeKeys(false)
+ ->scalarPrototype()->end()
+ ->end()
+ ->end()
+ ->arrayNode('elements')
+ ->defaultValue([])
+ ->info('Every key is a tag name, with an array of four values as definition. The fourth is an optional array of attributes rules.')
+ ->normalizeKeys(false)
+ ->useAttributeAsKey('tag_name')
+ ->info('An array represents a definition, with three required elements: a type ("Inline", "Block", ...), a content type ("Empty", "Optional: #PCDATA", ...), an attributes set ("Core", "Common", ...), a fourth optional may define attributes rules as array, and fifth for forbidden attributes.')
+ ->arrayPrototype()
+ ->validate()
+ ->ifTrue(function ($array) {
+ $count = count($array);
+
+ return 3 > $count || $count > 5;
+ })
+ ->thenInvalid('An element definition must define three to five elements: a type ("Inline", "Block", ...), a content type ("Empty", "Optional: #PCDATA", ...), an attributes set ("Core", "Common", ...), and a fourth optional may define attributes rules as array, and fifth for forbidden attributes.')
+ ->end()
+ ->variablePrototype()->end()
+ ->end()
+ ->end()
+ ->arrayNode('blank_elements')
+ ->defaultValue([])
+ ->info('An array of tag names that should purify everything.')
+ ->scalarPrototype()->end()
+ ->end()
+ ->arrayNode('parents')
+ ->defaultValue([])
+ ->info('An array of config names that should be inherited.')
+ ->scalarPrototype()->end()
+ ->end()
+ ->end()
+ ->end()
+ ->end()
+ ->end()
+ ;
+
+ return $treeBuilder;
+ }
+}
diff --git a/src/DependencyInjection/ExerciseHTMLPurifierExtension.php b/src/DependencyInjection/ExerciseHTMLPurifierExtension.php
new file mode 100644
index 00000000..061a4043
--- /dev/null
+++ b/src/DependencyInjection/ExerciseHTMLPurifierExtension.php
@@ -0,0 +1,125 @@
+load('services.php');
+
+ $configs = $this->processConfiguration(new Configuration(), $configs);
+
+ // Set default serializer cache path, while ensuring a default profile is defined
+ $configs['html_profiles']['default']['config']['Cache.SerializerPath'] = $configs['default_cache_serializer_path'];
+
+ if (!isset($configs['html_profiles']['default']['config']['Cache.SerializerPermissions'])) {
+ $configs['html_profiles']['default']['config']['Cache.SerializerPermissions'] = $configs['default_cache_serializer_permissions'];
+ }
+
+ $serializerPaths = [];
+
+ foreach ($configs['html_profiles'] as $name => $definition) {
+ $configId = "exercise_html_purifier.config.$name";
+ $default = null;
+ $parents = []; // stores inherited configs
+
+ if ('default' !== $name) {
+ $default = new Reference('exercise_html_purifier.config.default');
+ $parentNames = $definition['parents'];
+
+ unset($parentNames['default']); // default is always inherited
+ foreach ($parentNames as $parentName) {
+ self::resolveProfileInheritance($parentName, $configs['html_profiles'], $parents);
+ }
+ }
+
+ $container->register($configId, \HTMLPurifier_Config::class)
+ ->setFactory([HTMLPurifierConfigFactory::class, 'create'])
+ ->setArguments([
+ $name,
+ $definition['config'],
+ $default,
+ self::getResolvedConfig('config', $parents),
+ self::getResolvedConfig('attributes', $parents, $definition),
+ self::getResolvedConfig('elements', $parents, $definition),
+ self::getResolvedConfig('blank_elements', $parents, $definition),
+ ])
+ ;
+
+ $id = "exercise_html_purifier.$name";
+ $container->register($id, \HTMLPurifier::class)
+ ->setArguments([new Reference($configId)])
+ ->addTag(HTMLPurifierPass::PURIFIER_TAG, ['profile' => $name])
+ ;
+
+ if (isset($definition['config']['Cache.SerializerPath'])) {
+ $serializerPaths[] = $definition['config']['Cache.SerializerPath'];
+ }
+
+ if ($default) {
+ $container->registerAliasForArgument($id, \HTMLPurifier::class, "$name.purifier");
+ }
+ }
+
+ $container->register('exercise_html_purifier.purifiers_registry', HTMLPurifiersRegistry::class)
+ ->setPublic(false)
+ ;
+ $container->setAlias(HTMLPurifiersRegistryInterface::class, 'exercise_html_purifier.purifiers_registry')
+ ->setPublic(false)
+ ;
+ $container->setAlias(\HTMLPurifier::class, 'exercise_html_purifier.default')
+ ->setPublic(false)
+ ;
+ $container->getDefinition('exercise_html_purifier.cache_warmer.serializer')
+ ->setArgument(0, array_unique($serializerPaths))
+ ->setArgument(1, array_keys($configs['html_profiles']))
+ ;
+ }
+
+ public function getAlias(): string
+ {
+ return 'exercise_html_purifier';
+ }
+
+ private static function resolveProfileInheritance(string $parent, array $configs, array &$resolved): void
+ {
+ if (isset($resolved[$parent])) {
+ // Another profile already inherited this config, skip
+ return;
+ }
+
+ foreach ($configs[$parent]['parents'] as $grandParent) {
+ self::resolveProfileInheritance($grandParent, $configs, $resolved);
+ }
+
+ $resolved[$parent]['config'] = $configs[$parent]['config'];
+ $resolved[$parent]['attributes'] = $configs[$parent]['attributes'];
+ $resolved[$parent]['elements'] = $configs[$parent]['elements'];
+ $resolved[$parent]['blank_elements'] = $configs[$parent]['blank_elements'];
+ }
+
+ private static function getResolvedConfig(string $parameter, array $parents, ?array $definition = null): array
+ {
+ if (null !== $definition) {
+ return array_filter(array_merge(
+ array_column($parents, $parameter),
+ isset($definition[$parameter]) ? $definition[$parameter] : []
+ ));
+ }
+
+ return array_filter(array_column($parents, $parameter));
+ }
+}
diff --git a/src/ExerciseHTMLPurifierBundle.php b/src/ExerciseHTMLPurifierBundle.php
new file mode 100644
index 00000000..395a5196
--- /dev/null
+++ b/src/ExerciseHTMLPurifierBundle.php
@@ -0,0 +1,15 @@
+addCompilerPass(new HTMLPurifierPass());
+ }
+}
diff --git a/src/Form/Listener/HTMLPurifierListener.php b/src/Form/Listener/HTMLPurifierListener.php
new file mode 100644
index 00000000..2377acf7
--- /dev/null
+++ b/src/Form/Listener/HTMLPurifierListener.php
@@ -0,0 +1,50 @@
+registry = $registry;
+ $this->profile = $profile;
+ }
+
+ public function purifySubmittedData(FormEvent $event): void
+ {
+ if (!is_scalar($data = $event->getData())) {
+ // Hope there is a view transformer, otherwise an error might happen
+ return; // because we don't want to handle it here
+ }
+
+ if (0 === strlen($submittedData = trim((string) $data))) {
+ if ($submittedData !== $data) {
+ $event->setData($submittedData);
+ }
+
+ return;
+ }
+
+ $event->setData($this->getPurifier()->purify($submittedData));
+ }
+
+ public static function getSubscribedEvents(): array
+ {
+ return [
+ FormEvents::PRE_SUBMIT => ['purifySubmittedData', /* as soon as possible */ 1000000],
+ ];
+ }
+
+ private function getPurifier(): \HTMLPurifier
+ {
+ return $this->registry->get($this->profile);
+ }
+}
diff --git a/src/Form/TypeExtension/HTMLPurifierTextTypeExtension.php b/src/Form/TypeExtension/HTMLPurifierTextTypeExtension.php
new file mode 100644
index 00000000..4af73ec1
--- /dev/null
+++ b/src/Form/TypeExtension/HTMLPurifierTextTypeExtension.php
@@ -0,0 +1,63 @@
+purifiersRegistry = $registry;
+ }
+
+ public static function getExtendedTypes(): iterable
+ {
+ return [TextType::class];
+ }
+
+ public function configureOptions(OptionsResolver $resolver): void
+ {
+ $resolver
+ ->setDefaults([
+ 'purify_html' => false,
+ 'purify_html_profile' => 'default',
+ ])
+ ->setAllowedTypes('purify_html', 'bool')
+ ->setAllowedTypes('purify_html_profile', ['string', 'null'])
+ ->setNormalizer('purify_html_profile', function (Options $options, $profile) {
+ if (!$options['purify_html']) {
+ return null;
+ }
+
+ if ($this->purifiersRegistry->has($profile)) {
+ return $profile;
+ }
+
+ throw new InvalidOptionsException(sprintf('The profile "%s" is not registered.', $profile));
+ })
+ ->setNormalizer('trim', function (Options $options, $trim) {
+ // trim is done in the HTMLPurifierListener
+ return $options['purify_html'] ? false : $trim;
+ })
+ ;
+ }
+
+ public function buildForm(FormBuilderInterface $builder, array $options): void
+ {
+ if ($options['purify_html']) {
+ $builder->addEventSubscriber(
+ new HTMLPurifierListener($this->purifiersRegistry, $options['purify_html_profile'])
+ );
+ }
+ }
+}
diff --git a/src/HTMLPurifierConfigFactory.php b/src/HTMLPurifierConfigFactory.php
new file mode 100644
index 00000000..e8e88e4e
--- /dev/null
+++ b/src/HTMLPurifierConfigFactory.php
@@ -0,0 +1,88 @@
+ ['src' => 'URI', 'data-type' => Text']] ]
+ * @param array $elements An array of arrays by element to add or override, arrays must
+ * hold a type ("Inline, "Block", ...), a content type ("Empty",
+ * "Optional: #PCDATA", ...), an attributes set ("Core", "Common",
+ * ...), a fourth optional may define attributes rules as array, and
+ * a fifth to list forbidden attributes
+ * @param array $blankElements An array of tag names that should not have any attributes
+ */
+ public static function create(
+ string $profile,
+ array $configArray,
+ ?\HTMLPurifier_Config $defaultConfig = null,
+ array $parents = [],
+ array $attributes = [],
+ array $elements = [],
+ array $blankElements = [],
+ ): \HTMLPurifier_Config {
+ if ($defaultConfig) {
+ $config = \HTMLPurifier_Config::inherit($defaultConfig);
+ } else {
+ $config = \HTMLPurifier_Config::createDefault();
+ }
+
+ foreach ($parents as $parent) {
+ $config->loadArray($parent);
+ }
+
+ $config->loadArray($configArray);
+
+ // Make the config unique
+ $config->set('HTML.DefinitionID', $profile);
+ $config->set('HTML.DefinitionRev', 1);
+
+ $def = $config->maybeGetRawHTMLDefinition();
+
+ // If the definition is not cached, build it
+ if ($def && ($attributes || $elements || $blankElements)) {
+ static::buildHTMLDefinition($def, $attributes, $elements, $blankElements);
+ }
+
+ return $config;
+ }
+
+ /**
+ * Builds a config definition from the given parameters.
+ *
+ * This build should never happen on runtime, since purifiers cache should
+ * be generated during warm up.
+ */
+ public static function buildHTMLDefinition(\HTMLPurifier_HTMLDefinition $def, array $attributes, array $elements, array $blankElements): void
+ {
+ foreach ($attributes as $elementName => $rule) {
+ foreach ($rule as $attributeName => $definition) {
+ /* @see \HTMLPurifier_AttrTypes */
+ $def->addAttribute($elementName, $attributeName, $definition);
+ }
+ }
+
+ foreach ($elements as $elementName => $config) {
+ /* @see \HTMLPurifier_HTMLModule::addElement() */
+ $el = $def->addElement($elementName, $config[0], $config[1], $config[2], isset($config[3]) ? $config[3] : []);
+
+ if (isset($config[4])) {
+ $el->excludes = array_fill_keys($config[4], true);
+ }
+ }
+
+ foreach ($blankElements as $blankElement) {
+ /* @see \HTMLPurifier_HTMLModule::addBlankElement() */
+ $def->addBlankElement($blankElement);
+ }
+ }
+}
diff --git a/src/HTMLPurifiersRegistry.php b/src/HTMLPurifiersRegistry.php
new file mode 100644
index 00000000..9e4cef1e
--- /dev/null
+++ b/src/HTMLPurifiersRegistry.php
@@ -0,0 +1,25 @@
+purifiersLocator = $purifiersLocator;
+ }
+
+ public function has(string $profile): bool
+ {
+ return $this->purifiersLocator->has($profile);
+ }
+
+ public function get(string $profile): \HTMLPurifier
+ {
+ return $this->purifiersLocator->get($profile);
+ }
+}
diff --git a/src/HTMLPurifiersRegistryInterface.php b/src/HTMLPurifiersRegistryInterface.php
new file mode 100644
index 00000000..0f484a72
--- /dev/null
+++ b/src/HTMLPurifiersRegistryInterface.php
@@ -0,0 +1,10 @@
+services()
+ ->set('exercise_html_purifier.cache_warmer.serializer', SerializerCacheWarmer::class)
+ ->tag('kernel.cache_warmer')
+ ->args([
+ abstract_arg('cache paths'),
+ abstract_arg('profiles'),
+ service(HTMLPurifiersRegistryInterface::class),
+ service('filesystem'),
+ ])
+
+ ->set('exercise_html_purifier.form.text_type_extension', HTMLPurifierTextTypeExtension::class)
+ ->tag('form.type_extension', ['extended_type' => TextType::class])
+ ->args([
+ service(HTMLPurifiersRegistryInterface::class),
+ ])
+
+ ->set('exercise_html_purifier.twig.extension', HTMLPurifierExtension::class)
+ ->tag('twig.extension')
+
+ ->set('exercise_html_purifier.twig.runtime', HTMLPurifierRuntime::class)
+ ->tag('twig.runtime')
+ ->args([
+ service(HTMLPurifiersRegistryInterface::class),
+ ]);
+};
diff --git a/src/Twig/HTMLPurifierExtension.php b/src/Twig/HTMLPurifierExtension.php
new file mode 100644
index 00000000..2c922d88
--- /dev/null
+++ b/src/Twig/HTMLPurifierExtension.php
@@ -0,0 +1,16 @@
+ ['html']]),
+ ];
+ }
+}
diff --git a/src/Twig/HTMLPurifierRuntime.php b/src/Twig/HTMLPurifierRuntime.php
new file mode 100644
index 00000000..f1ba5df4
--- /dev/null
+++ b/src/Twig/HTMLPurifierRuntime.php
@@ -0,0 +1,43 @@
+purifiersRegistry = $registry;
+ }
+
+ /**
+ * Filters the input through an \HTMLPurifier service.
+ *
+ * @param string|null $string The html string to purify
+ * @param string $profile A configuration profile name
+ *
+ * @return string The purified html string
+ */
+ public function purify(?string $string, string $profile = 'default'): string
+ {
+ if (null === $string) {
+ return '';
+ }
+
+ return $this->getHTMLPurifierForProfile($profile)->purify($string);
+ }
+
+ /**
+ * Gets the HTMLPurifier service corresponding to the given profile.
+ *
+ * @throws \InvalidArgumentException If the profile does not exist
+ */
+ private function getHTMLPurifierForProfile(string $profile): \HTMLPurifier
+ {
+ return $this->purifiersRegistry->get($profile);
+ }
+}
diff --git a/tests/CacheWarmer/SerializerCacheWarmerTest.php b/tests/CacheWarmer/SerializerCacheWarmerTest.php
new file mode 100644
index 00000000..b21ec241
--- /dev/null
+++ b/tests/CacheWarmer/SerializerCacheWarmerTest.php
@@ -0,0 +1,55 @@
+createMock(HTMLPurifiersRegistryInterface::class), new Filesystem());
+
+ $this->assertFalse($cacheWarmer->isOptional());
+ }
+
+ public function testWarmUpShouldCreatePaths(): void
+ {
+ $fs = new Filesystem();
+ $path = sys_get_temp_dir().DIRECTORY_SEPARATOR.'html_purifier';
+
+ if ($fs->exists($path)) {
+ $fs->remove($path);
+ }
+
+ $this->assertFalse($fs->exists($path));
+
+ $cacheWarmer = new SerializerCacheWarmer([$path], [], $this->createMock(HTMLPurifiersRegistryInterface::class), $fs);
+ $cacheWarmer->warmUp('');
+
+ $this->assertTrue($fs->exists($path));
+
+ $fs->remove($path);
+ }
+
+ public function testWarmUpShouldCallPurifyForEachProfile(): void
+ {
+ $purifier = $this->createMock(\HTMLPurifier::class);
+ $purifier->expects($this->exactly(2))
+ ->method('purify')
+ ;
+
+ $registry = $this->createMock(HTMLPurifiersRegistryInterface::class);
+ $registry->expects($this->exactly(2))
+ ->method('get')
+ ->withConsecutive(['first'], ['second'])
+ ->willReturn($purifier)
+ ;
+
+ $cacheWarmer = new SerializerCacheWarmer([], ['first', 'second'], $registry, new Filesystem());
+ $cacheWarmer->warmUp('');
+ }
+}
diff --git a/tests/DependencyInjection/Compiler/HTMLPurifierPassTest.php b/tests/DependencyInjection/Compiler/HTMLPurifierPassTest.php
new file mode 100644
index 00000000..f5ef7090
--- /dev/null
+++ b/tests/DependencyInjection/Compiler/HTMLPurifierPassTest.php
@@ -0,0 +1,116 @@
+container = $this->createPartialMock(ContainerBuilder::class, [
+ 'hasAlias',
+ 'findDefinition',
+ 'findTaggedServiceIds',
+ 'getDefinition',
+ ]);
+ }
+
+ protected function tearDown(): void
+ {
+ $this->container = null;
+ }
+
+ public function testProcessOnlyIfRegistryInterfaceIsDefined(): void
+ {
+ $this->container->expects($this->once())
+ ->method('hasAlias')
+ ->with(HTMLPurifiersRegistryInterface::class)
+ ->willReturn(false)
+ ;
+ $this->container->expects($this->never())
+ ->method('findDefinition')
+ ;
+
+ $pass = new HTMLPurifierPass();
+
+ $pass->process($this->container);
+ }
+
+ public function testProcess(): void
+ {
+ $container = new ContainerBuilder();
+ $purifier = $container->register(DummyPurifier::class)
+ ->addTag('exercise.html_purifier', ['profile' => 'test'])
+ ;
+ $registry = $container->register('exercise_html_purifier.purifiers_registry', HTMLPurifiersRegistry::class);
+
+ $container->setAlias(HTMLPurifiersRegistryInterface::class, 'exercise_html_purifier.purifiers_registry');
+
+ $pass = new HTMLPurifierPass();
+ $pass->process($container);
+
+ $this->assertInstanceOf(Reference::class, $config = $purifier->getArgument(0));
+ $this->assertSame('exercise_html_purifier.config.default', (string) $config);
+ $this->assertInstanceOf(Definition::class, $locator = $container->findDefinition($registry->getArgument(0)));
+ $this->assertArrayHasKey('test', $map = $locator->getArgument(0));
+ $this->assertInstanceOf(ServiceClosureArgument::class, $map['test']);
+ $this->assertSame(DummyPurifier::class, (string) $map['test']->getValues()[0]);
+ }
+
+ public function testProcessDoNothingIfRegistryIsNotDefined(): void
+ {
+ $this->container
+ ->expects($this->once())
+ ->method('hasAlias')
+ ->with(HTMLPurifiersRegistryInterface::class)
+ ->willReturn(true)
+ ;
+ $this->container
+ ->expects($this->once())
+ ->method('findDefinition')
+ ->with(HTMLPurifiersRegistryInterface::class)
+ ->willThrowException($this->createMock(ServiceNotFoundException::class))
+ ;
+ $this->container
+ ->expects($this->never())
+ ->method('findTaggedServiceIds')
+ ;
+
+ $pass = new HTMLPurifierPass();
+ $pass->process($this->container);
+ }
+
+ public function testProcessFailsIfTaggedServiceMissesProfileName(): void
+ {
+ $container = new ContainerBuilder();
+ $container->register(DummyPurifier::class)
+ ->addTag('exercise.html_purifier')
+ ;
+ $container->register('exercise_html_purifier.purifiers_registry', HTMLPurifiersRegistry::class);
+ $container->setAlias(HTMLPurifiersRegistryInterface::class, 'exercise_html_purifier.purifiers_registry');
+
+ $this->expectException(InvalidConfigurationException::class);
+ $this->expectExceptionMessage('Tag "exercise.html_purifier" must define a "profile" attribute.');
+
+ $pass = new HTMLPurifierPass();
+ $pass->process($container);
+ }
+}
+
+class DummyPurifier extends \HTMLPurifier
+{
+}
diff --git a/tests/DependencyInjection/ExerciseHTMLPurifierExtensionTest.php b/tests/DependencyInjection/ExerciseHTMLPurifierExtensionTest.php
new file mode 100644
index 00000000..fde6d8f8
--- /dev/null
+++ b/tests/DependencyInjection/ExerciseHTMLPurifierExtensionTest.php
@@ -0,0 +1,516 @@
+container = new ContainerBuilder();
+ $this->container->setParameter('kernel.cache_dir', '/tmp');
+ $this->extension = new ExerciseHTMLPurifierExtension();
+ $this->defaultConfig = [
+ 'Cache.SerializerPath' => self::DEFAULT_CACHE_PATH,
+ 'Cache.SerializerPermissions' => self::DEFAULT_CACHE_PERMISSIONS,
+ ];
+ }
+
+ public function tearDown(): void
+ {
+ $this->defaultConfig = null;
+ $this->extension = null;
+ $this->container = null;
+ }
+
+ public function testShouldLoadDefaultConfiguration(): void
+ {
+ $this->extension->load([], $this->container);
+
+ $this->assertDefaultConfigDefinition($this->defaultConfig);
+ $this->assertCacheWarmerSerializerArgs([self::DEFAULT_CACHE_PATH], ['default']);
+ $this->assertRegistryHasProfiles(['default']);
+ }
+
+ public function testInvalidParent(): void
+ {
+ $config = [
+ 'html_profiles' => [
+ 'custom' => [
+ 'config' => ['AutoFormat.AutoParagraph' => true],
+ ],
+ 'custom_2' => [
+ 'config' => ['AutoFormat.Linkify' => true],
+ 'parents' => ['custom', 'unknown'],
+ ],
+ ],
+ ];
+
+ $this->expectException(InvalidConfigurationException::class);
+ $this->expectExceptionMessage('Invalid parent "unknown" is not defined for profile "custom_2".');
+
+ $this->extension->load([$config], $this->container);
+ }
+
+ /**
+ * @dataProvider provideInvalidElementDefinitions
+ */
+ public function testInvalidElements(array $elementDefinition): void
+ {
+ $config = [
+ 'html_profiles' => [
+ 'default' => [
+ 'elements' => ['a' => $elementDefinition],
+ ],
+ ],
+ ];
+
+ $this->expectException(InvalidConfigurationException::class);
+ $this->expectExceptionMessage('Invalid configuration for path "exercise_html_purifier.html_profiles.default.elements.a": An element definition must define three to five elements: a type ("Inline", "Block", ...), a content type ("Empty", "Optional: #PCDATA", ...), an attributes set ("Core", "Common", ...), and a fourth optional may define attributes rules as array, and fifth for forbidden attributes.');
+
+ $this->extension->load([$config], $this->container);
+ }
+
+ public function provideInvalidElementDefinitions(): iterable
+ {
+ yield 'empty array' => [[]];
+ yield 'only one argument' => [['']];
+ yield 'only two arguments' => [['', '']];
+ yield 'too many arguments' => [['', '', '', [], [], 'extra argument']];
+ }
+
+ public function testShouldAllowOverridingDefaultConfigurationCacheSerializerPath(): void
+ {
+ $config = [
+ 'default_cache_serializer_path' => null,
+ 'html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'AutoFormat.AutoParagraph' => true,
+ ],
+ ],
+ ],
+ ];
+
+ $this->extension->load([$config], $this->container);
+
+ $this->assertDefaultConfigDefinition(array_merge($config['html_profiles']['default']['config'], [
+ 'Cache.SerializerPath' => null,
+ 'Cache.SerializerPermissions' => 493,
+ ]));
+ $this->assertCacheWarmerSerializerArgs([], ['default']);
+ $this->assertRegistryHasProfiles(['default']);
+ }
+
+ public function testShouldAllowOverridingDefaultConfigurationCacheSerializerPermissions(): void
+ {
+ $config = [
+ 'default_cache_serializer_path' => null,
+ 'default_cache_serializer_permissions' => 511,
+ 'html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'AutoFormat.AutoParagraph' => true,
+ ],
+ ],
+ ],
+ ];
+
+ $this->extension->load([$config], $this->container);
+
+ $this->assertDefaultConfigDefinition(array_merge($config['html_profiles']['default']['config'], [
+ 'Cache.SerializerPath' => null,
+ 'Cache.SerializerPermissions' => 511,
+ ]));
+ $this->assertCacheWarmerSerializerArgs([], ['default']);
+ $this->assertRegistryHasProfiles(['default']);
+ }
+
+ public function testShouldAllowOverridingDefaultConfigurationCacheSerializerPermissionsOnDefaultProfile(): void
+ {
+ $config = [
+ 'default_cache_serializer_path' => null,
+ 'html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'AutoFormat.AutoParagraph' => true,
+ 'Cache.SerializerPermissions' => 511,
+ ],
+ ],
+ ],
+ ];
+
+ $this->extension->load([$config], $this->container);
+
+ $this->assertDefaultConfigDefinition(array_merge($config['html_profiles']['default']['config'], [
+ 'Cache.SerializerPath' => null,
+ 'Cache.SerializerPermissions' => 511,
+ ]));
+ $this->assertCacheWarmerSerializerArgs([], ['default']);
+ $this->assertRegistryHasProfiles(['default']);
+ }
+
+ public function testShouldNotDeepMergeOptions(): void
+ {
+ $configs = [
+ ['html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'Core.HiddenElements' => ['script' => true],
+ ],
+ ],
+ ]],
+ ['html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'Core.HiddenElements' => ['style' => true],
+ ],
+ ],
+ ]],
+ ];
+
+ $this->extension->load($configs, $this->container);
+
+ $this->assertDefaultConfigDefinition(array_merge([
+ 'Core.HiddenElements' => ['style' => true],
+ ], $this->defaultConfig));
+ $this->assertCacheWarmerSerializerArgs([self::DEFAULT_CACHE_PATH], ['default']);
+ $this->assertRegistryHasProfiles(['default']);
+ }
+
+ public function testShouldLoadCustomConfiguration(): void
+ {
+ $config = [
+ 'html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'AutoFormat.AutoParagraph' => true,
+ ],
+ ],
+ 'simple' => [
+ 'config' => [
+ 'Cache.DefinitionImpl' => null,
+ 'Cache.SerializerPath' => '%kernel.cache_dir%/htmlpurifier-simple',
+ 'AutoFormat.Linkify' => true,
+ 'AutoFormat.RemoveEmpty' => true,
+ 'AutoFormat.RemoveEmpty.RemoveNbsp' => true,
+ 'HTML.Allowed' => 'a[href],strong,em,p,li,ul,ol',
+ ],
+ ],
+ 'advanced' => [
+ 'config' => [
+ 'Cache.DefinitionImpl' => null,
+ ],
+ ],
+ ],
+ ];
+
+ $this->extension->load([$config], $this->container);
+
+ $profiles = ['default', 'simple', 'advanced'];
+
+ $this->assertDefaultConfigDefinition(array_merge($config['html_profiles']['default']['config'], $this->defaultConfig));
+ $this->assertConfigDefinition('simple', $config['html_profiles']['simple']['config']);
+ $this->assertConfigDefinition('advanced', $config['html_profiles']['advanced']['config']);
+ $this->assertCacheWarmerSerializerArgs([
+ self::DEFAULT_CACHE_PATH,
+ self::DEFAULT_CACHE_PATH.'-simple',
+ ], $profiles);
+ $this->assertRegistryHasProfiles($profiles);
+ }
+
+ public function testShouldLoadComplexCustomConfiguration(): void
+ {
+ $defaultConfig = [
+ 'AutoFormat.AutoParagraph' => true,
+ ];
+ $defaultAttributes = [
+ 'a' => ['href' => 'URI'],
+ 'span' => ['data-link' => 'URI'],
+ ];
+ $defaultBlankElements = [
+ 'figcaption',
+ 'legend',
+ ];
+ $simpleConfig = [
+ 'AutoFormat.Linkify' => true,
+ 'AutoFormat.RemoveEmpty' => true,
+ 'AutoFormat.RemoveEmpty.RemoveNbsp' => true,
+ 'HTML.Allowed' => 'a[href],strong,em,p,li,ul,ol',
+ ];
+ $videoElements = [
+ 'video' => [
+ 'Block',
+ 'Optional: (source, Flow) | (Flow, source) | Flow',
+ 'Common',
+ [
+ 'src' => 'URI',
+ 'type' => 'Text',
+ 'width' => 'Length',
+ 'height' => 'Length',
+ 'poster' => 'URI',
+ 'preload' => 'Enum#auto,metadata,none',
+ 'controls' => 'Bool',
+ ],
+ ],
+ ];
+ $advancedConfig = [
+ 'Core.HiddenElements' => ['script' => true],
+ ];
+ $allParents = ['simple', 'video', 'advanced'];
+
+ $config = [
+ 'html_profiles' => [
+ 'default' => [
+ 'config' => $defaultConfig,
+ 'attributes' => $defaultAttributes,
+ 'blank_elements' => $defaultBlankElements,
+ ],
+ 'simple' => [
+ 'config' => $simpleConfig,
+ ],
+ 'video' => [
+ 'elements' => $videoElements,
+ ],
+ 'advanced' => [
+ 'config' => $advancedConfig,
+ ],
+ 'all' => [
+ 'parents' => $allParents,
+ ],
+ ],
+ ];
+
+ $this->extension->load([$config], $this->container);
+
+ $profiles = ['default', 'simple', 'video', 'advanced', 'all'];
+
+ $this->assertDefaultConfigDefinition(
+ array_merge($defaultConfig, $this->defaultConfig),
+ $defaultAttributes,
+ [],
+ $defaultBlankElements
+ );
+ $this->assertConfigDefinition('simple', $simpleConfig);
+ $this->assertConfigDefinition(
+ 'video',
+ [/* config */],
+ [/* parents */],
+ [/* attributes */],
+ $videoElements
+ );
+ $this->assertConfigDefinition('advanced', $advancedConfig);
+ $this->assertConfigDefinition(
+ 'all',
+ [/* config */],
+ [$simpleConfig, /* video config is filtered */ 2 => $advancedConfig],
+ [/* attributes */],
+ [/* simple elements are filtered */ 1 => $videoElements],
+ [/* blank elements */]
+ );
+ $this->assertCacheWarmerSerializerArgs([self::DEFAULT_CACHE_PATH], $profiles);
+ $this->assertRegistryHasProfiles($profiles);
+ }
+
+ public function testShouldRegisterAliases(): void
+ {
+ if (!method_exists($this->container, 'registerAliasForArgument')) {
+ $this->markTestSkipped('Alias arguments binding is not available.');
+ }
+
+ $config = [
+ 'html_profiles' => [
+ 'default' => [
+ 'config' => [
+ 'AutoFormat.AutoParagraph' => true,
+ ],
+ ],
+ 'simple' => [
+ 'config' => [
+ 'HTML.Allowed' => 'a[href],strong,em,p,li,ul,ol',
+ ],
+ ],
+ 'advanced' => [
+ 'config' => [
+ 'Core.HiddenElements' => ['script' => true],
+ ],
+ ],
+ ],
+ ];
+
+ $this->extension->load([$config], $this->container);
+
+ $this->container->register(ServiceWithDefaultConfig::class)
+ ->setAutowired(true)
+ ->setPublic(true)
+ ;
+ $this->container->register(ServiceWithDefaultConfig2::class)
+ ->setAutowired(true)
+ ->setPublic(true)
+ ;
+ $this->container->register(ServiceWithSimpleConfig::class)
+ ->setAutowired(true)
+ ->setPublic(true)
+ ;
+ $this->container->register(ServiceWithAdvancedConfig::class)
+ ->setAutowired(true)
+ ->setPublic(true)
+ ;
+
+ $this->container->compile();
+
+ $defaultConfigArgument1 = $this->container->findDefinition(ServiceWithDefaultConfig::class)
+ ->getArgument(0)
+ ;
+
+ $this->assertInstanceOf(Reference::class, $defaultConfigArgument1);
+ $this->assertSame('exercise_html_purifier.default', (string) $defaultConfigArgument1);
+
+ $defaultConfigArgument2 = $this->container->findDefinition(ServiceWithDefaultConfig2::class)
+ ->getArgument(0)
+ ;
+
+ $this->assertInstanceOf(Reference::class, $defaultConfigArgument2);
+ $this->assertSame('exercise_html_purifier.default', (string) $defaultConfigArgument2);
+
+ $simpleConfigArgument = $this->container->findDefinition(ServiceWithSimpleConfig::class)
+ ->getArgument(0)
+ ;
+
+ $this->assertInstanceOf(Definition::class, $simpleConfigArgument);
+ $this->assertSame(
+ 'simple',
+ $simpleConfigArgument->getTag(HTMLPurifierPass::PURIFIER_TAG)[0]['profile'] ?? ''
+ );
+
+ $advancedConfigArgument = $this->container->findDefinition(ServiceWithAdvancedConfig::class)
+ ->getArgument(0)
+ ;
+
+ $this->assertInstanceOf(Definition::class, $advancedConfigArgument);
+ $this->assertSame(
+ 'advanced',
+ $advancedConfigArgument->getTag(HTMLPurifierPass::PURIFIER_TAG)[0]['profile'] ?? ''
+ );
+ }
+
+ /**
+ * Asserts that the named config definition extends the default profile and
+ * loads the given options.
+ */
+ private function assertConfigDefinition(string $name, array $config, array $parents = [], array $attributes = [], array $elements = [], array $blankElements = []): void
+ {
+ $this->assertTrue($this->container->hasDefinition('exercise_html_purifier.config.'.$name));
+
+ $definition = $this->container->getDefinition('exercise_html_purifier.config.'.$name);
+
+ $this->assertEquals([new Reference(HTMLPurifierConfigFactory::class), 'create'], $definition->getFactory());
+
+ $args = $definition->getArguments();
+ $defaultConfig = $definition->getArgument(2);
+
+ $this->assertCount(7, $args);
+ $this->assertSame($name, $definition->getArgument(0));
+ $this->assertSame($config, $definition->getArgument(1));
+ $this->assertInstanceOf(Reference::class, $defaultConfig);
+ $this->assertSame('exercise_html_purifier.config.default', (string) $defaultConfig);
+ $this->assertSame($parents, $definition->getArgument(3));
+ $this->assertSame($attributes, $definition->getArgument(4));
+ $this->assertSame($elements, $definition->getArgument(5));
+ $this->assertSame($blankElements, $definition->getArgument(6));
+ }
+
+ /**
+ * Asserts that the default config definition loads the given options.
+ */
+ private function assertDefaultConfigDefinition(array $config, array $attributes = [], array $elements = [], array $blankElements = []): void
+ {
+ $this->assertTrue($this->container->hasDefinition('exercise_html_purifier.config.default'));
+
+ $definition = $this->container->getDefinition('exercise_html_purifier.config.default');
+
+ $this->assertEquals([new Reference(HTMLPurifierConfigFactory::class), 'create'], $definition->getFactory());
+ $this->assertSame(['default', $config, null, [], $attributes, $elements, $blankElements], $definition->getArguments(), 'Default config is invalid.');
+ }
+
+ /**
+ * Asserts that the registry has profiles.
+ *
+ * @param string[] $profiles
+ */
+ private function assertRegistryHasProfiles(array $profiles): void
+ {
+ foreach ($profiles as $profile) {
+ $this->assertTrue($this->container->hasDefinition("exercise_html_purifier.$profile"));
+ $this->assertTrue($this->container->hasDefinition("exercise_html_purifier.config.$profile"));
+ }
+ }
+
+ /**
+ * Assert that the cache warmer serializer paths equal the given array.
+ */
+ private function assertCacheWarmerSerializerArgs(array $paths, array $profiles): void
+ {
+ $serializer = $this->container->getDefinition('exercise_html_purifier.cache_warmer.serializer');
+
+ $this->assertSame($serializer->getArgument(0), $paths);
+ $this->assertSame($serializer->getArgument(1), $profiles);
+ $this->assertSame((string) $serializer->getArgument(2), HTMLPurifiersRegistryInterface::class);
+ $this->assertSame((string) $serializer->getArgument(3), 'filesystem');
+ }
+}
+
+class ServiceWithDefaultConfig
+{
+ public function __construct(\HTMLPurifier $purifier)
+ {
+ }
+}
+
+class ServiceWithDefaultConfig2
+{
+ public function __construct(\HTMLPurifier $htmlPurifier)
+ {
+ }
+}
+
+class ServiceWithSimpleConfig
+{
+ public function __construct(\HTMLPurifier $simplePurifier)
+ {
+ }
+}
+
+class ServiceWithAdvancedConfig
+{
+ public function __construct(\HTMLPurifier $advancedPurifier)
+ {
+ }
+}
diff --git a/tests/Form/Listener/HTMLPurifierListenerTest.php b/tests/Form/Listener/HTMLPurifierListenerTest.php
new file mode 100644
index 00000000..bf5e73c6
--- /dev/null
+++ b/tests/Form/Listener/HTMLPurifierListenerTest.php
@@ -0,0 +1,108 @@
+text';
+
+ $purifier = $this->createMock('HTMLPurifier');
+ $purifier
+ ->expects($this->once())
+ ->method('purify')
+ ->with($input)
+ ->willReturn($purifiedInput)
+ ;
+
+ $profile = 'test';
+ $registry = $this->createMock(HTMLPurifiersRegistryInterface::class);
+ $registry
+ ->expects($this->once())
+ ->method('get')
+ ->with($profile)
+ ->willReturn($purifier)
+ ;
+
+ $listener = new HTMLPurifierListener($registry, $profile);
+
+ $event = $this->getFormEvent($input);
+
+ $listener->purifySubmittedData($event);
+
+ $this->assertSame($purifiedInput, $event->getData());
+ }
+
+ public function testPurifyTrimEmptyValues(): void
+ {
+ $input = ' ';
+ $trimmedInput = '';
+
+ $purifier = $this->createMock('HTMLPurifier');
+ $purifier
+ ->expects($this->never())
+ ->method('purify')
+ ;
+
+ $registry = $this->createMock(HTMLPurifiersRegistryInterface::class);
+ $registry
+ ->expects($this->never())
+ ->method('get')
+ ;
+
+ $listener = new HTMLPurifierListener($registry, 'test');
+
+ $event = $this->getFormEvent($input);
+
+ $listener->purifySubmittedData($event);
+
+ $this->assertSame($trimmedInput, $event->getData());
+ }
+
+ /**
+ * @dataProvider provideInvalidInput
+ */
+ public function testPurifyDoNothingForEmptyOrNonScalarData($input): void
+ {
+ $registry = $this->createMock(HTMLPurifiersRegistryInterface::class);
+ $registry
+ ->expects($this->never())
+ ->method('get')
+ ;
+
+ $listener = new HTMLPurifierListener($registry, 'test');
+
+ $event = $this->createMock(FormEvent::class);
+ $event
+ ->expects($this->once())
+ ->method('getData')
+ ->willReturn($input)
+ ;
+ $event
+ ->expects($this->never())
+ ->method('setData')
+ ;
+
+ $listener->purifySubmittedData($event);
+ }
+
+ public function provideInvalidInput(): iterable
+ {
+ yield [''];
+ yield [[]];
+ yield [new \stdClass()];
+ }
+
+ private function getFormEvent($data): FormEvent
+ {
+ return new FormEvent($this->createMock(FormInterface::class), $data);
+ }
+}
diff --git a/tests/Form/TypeExtension/HTMLPurifierTextTypeExtensionTest.php b/tests/Form/TypeExtension/HTMLPurifierTextTypeExtensionTest.php
new file mode 100644
index 00000000..84682181
--- /dev/null
+++ b/tests/Form/TypeExtension/HTMLPurifierTextTypeExtensionTest.php
@@ -0,0 +1,130 @@
+registry = $this->createMock(HTMLPurifiersRegistryInterface::class);
+
+ parent::setUp();
+ }
+
+ protected function tearDown(): void
+ {
+ parent::tearDown();
+
+ $this->registry = null;
+ }
+
+ protected function getTypeExtensions(): array
+ {
+ return [
+ new HTMLPurifierTextTypeExtension($this->registry),
+ ];
+ }
+
+ public function testDefaultOptions(): void
+ {
+ $this->registry
+ ->expects($this->never())
+ ->method('has')
+ ;
+ $this->registry
+ ->expects($this->never())
+ ->method('get')
+ ;
+
+ $form = $this->factory->create(TextType::class);
+ $options = $form->getConfig()->getOptions();
+
+ $this->assertFalse($options['purify_html']);
+ $this->assertNull($options['purify_html_profile']);
+ $this->assertTrue($options['trim']);
+ $this->assertFalse($this->hasPurifierListener($form));
+ }
+
+ public function testPurifyOptionsNeedDefaultProfile(): void
+ {
+ $this->registry
+ ->expects($this->once())
+ ->method('has')
+ ->with('default')
+ ->willReturn(false)
+ ;
+ $this->registry
+ ->expects($this->never())
+ ->method('get')
+ ;
+
+ $this->expectException(InvalidOptionsException::class);
+ $this->expectExceptionMessage('The profile "default" is not registered.');
+
+ $this->factory->create(TextType::class, null, ['purify_html' => true]);
+ }
+
+ public function testDefaultOptionsWhenPurifyIsTrue(): void
+ {
+ $this->registry
+ ->expects($this->once())
+ ->method('has')
+ ->with('default')
+ ->willReturn(true)
+ ;
+
+ $form = $this->factory->create(TextType::class, null, ['purify_html' => true]);
+ $options = $form->getConfig()->getOptions();
+
+ $this->assertTrue($options['purify_html']);
+ $this->assertSame('default', $options['purify_html_profile']);
+ $this->assertFalse($options['trim']);
+ $this->assertTrue($this->hasPurifierListener($form));
+ }
+
+ public function testInvalidProfile(): void
+ {
+ $this->registry
+ ->expects($this->once())
+ ->method('has')
+ ->with('test')
+ ->willReturn(false)
+ ;
+ $this->registry
+ ->expects($this->never())
+ ->method('get')
+ ;
+
+ $this->expectException(InvalidOptionsException::class);
+ $this->expectExceptionMessage('The profile "test" is not registered.');
+
+ $this->factory->create(TextType::class, null, [
+ 'purify_html' => true,
+ 'purify_html_profile' => 'test',
+ ]);
+ }
+
+ private function hasPurifierListener(FormInterface $form): bool
+ {
+ foreach ($form->getConfig()->getEventDispatcher()->getListeners(FormEvents::PRE_SUBMIT) as $listener) {
+ if ($listener[0] instanceof HTMLPurifierListener) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/tests/HTMLPurifierConfigFactoryTest.php b/tests/HTMLPurifierConfigFactoryTest.php
new file mode 100644
index 00000000..ff780bfe
--- /dev/null
+++ b/tests/HTMLPurifierConfigFactoryTest.php
@@ -0,0 +1,69 @@
+mkdir(self::$cacheDir);
+ }
+
+ public static function tearDownAfterClass(): void
+ {
+ (new Filesystem())->remove(self::$cacheDir);
+ }
+
+ public function testCreateUseDoesNotBuildDefinitionByDefault(): void
+ {
+ TestHTMLPurifierConfigFactory::create('default', []);
+
+ $this->assertSame(0, TestHTMLPurifierConfigFactory::$calledBuild);
+ }
+
+ public function testCreateUseSerializedCache(): void
+ {
+ $configArgs = [
+ 'test', /* profile */
+ [/* config array */
+ 'Cache.SerializerPath' => self::$cacheDir,
+ 'HTML.Nofollow' => true,
+ ],
+ null, /* default config */
+ [], /* parents */
+ ['a' => ['href' => 'URI']], /* attributes */
+ ];
+
+ (new \HTMLPurifier(
+ TestHTMLPurifierConfigFactory::create(...$configArgs)
+ ))->purify('
test
');
+
+ TestHTMLPurifierConfigFactory::create(...$configArgs);
+
+ $this->assertSame(1, TestHTMLPurifierConfigFactory::$calledBuild);
+ }
+}
+
+class TestHTMLPurifierConfigFactory extends HTMLPurifierConfigFactory
+{
+ /** @var int */
+ public static $calledBuild = 0;
+
+ public static function buildHTMLDefinition(
+ \HTMLPurifier_HTMLDefinition $def,
+ array $attributes,
+ array $elements,
+ array $blankElements,
+ ): void {
+ ++self::$calledBuild;
+ parent::buildHTMLDefinition($def, $attributes, $elements, $blankElements);
+ }
+}
diff --git a/tests/HTMLPurifiersRegistryTest.php b/tests/HTMLPurifiersRegistryTest.php
new file mode 100644
index 00000000..5dcfacea
--- /dev/null
+++ b/tests/HTMLPurifiersRegistryTest.php
@@ -0,0 +1,78 @@
+locator = $this->createMock(ContainerInterface::class);
+ $this->registry = new HTMLPurifiersRegistry($this->locator);
+ }
+
+ protected function tearDown(): void
+ {
+ $this->registry = null;
+ $this->locator = null;
+ }
+
+ public function provideProfiles(): iterable
+ {
+ yield ['default'];
+ yield ['test'];
+ }
+
+ /**
+ * @dataProvider provideProfiles
+ */
+ public function testHas(string $profile): void
+ {
+ $this->locator->expects($this->once())
+ ->method('has')
+ ->with($profile)
+ ->willReturn(true)
+ ;
+
+ $this->assertTrue($this->registry->has($profile));
+ }
+
+ /**
+ * @dataProvider provideProfiles
+ */
+ public function testHasNot(string $profile): void
+ {
+ $this->locator->expects($this->once())
+ ->method('has')
+ ->with($profile)
+ ->willReturn(false)
+ ;
+
+ $this->assertFalse($this->registry->has($profile));
+ }
+
+ /**
+ * @dataProvider provideProfiles
+ */
+ public function testGet(string $profile): void
+ {
+ $purifier = $this->createMock(\HTMLPurifier::class);
+
+ $this->locator->expects($this->once())
+ ->method('get')
+ ->with($profile)
+ ->willReturn($purifier)
+ ;
+
+ $this->assertSame($purifier, $this->registry->get($profile));
+ }
+}
diff --git a/tests/Twig/HTMLPurifierRuntimeTest.php b/tests/Twig/HTMLPurifierRuntimeTest.php
new file mode 100644
index 00000000..21594ddb
--- /dev/null
+++ b/tests/Twig/HTMLPurifierRuntimeTest.php
@@ -0,0 +1,46 @@
+text';
+
+ $purifier = $this->getMockBuilder('HTMLPurifier')
+ ->disableOriginalConstructor()
+ ->getMock();
+
+ $purifier->expects($this->once())
+ ->method('purify')
+ ->with($input)
+ ->will($this->returnValue($purifiedInput));
+
+ $registry = $this->createMock(HTMLPurifiersRegistryInterface::class);
+
+ $registry->expects($this->once())
+ ->method('get')
+ ->with($profile)
+ ->will($this->returnValue($purifier))
+ ;
+
+ $extension = new HTMLPurifierRuntime($registry);
+
+ $this->assertEquals($purifiedInput, $extension->purify($input, $profile));
+ }
+
+ public function providePurifierProfiles(): iterable
+ {
+ yield ['default'];
+ yield ['custom'];
+ }
+}