View source
<?php
declare (strict_types=1);
namespace Drupal\Tests\Core\Template;
use Drupal\Component\Serialization\Json;
use Drupal\Core\File\FileUrlGeneratorInterface;
use Drupal\Core\GeneratedLink;
use Drupal\Core\Render\Markup;
use Drupal\Core\Render\RenderableInterface;
use Drupal\Core\StringTranslation\TranslatableMarkup;
use Drupal\Core\Template\Attribute;
use Drupal\Core\Template\Loader\StringLoader;
use Drupal\Core\Template\TwigEnvironment;
use Drupal\Core\Template\TwigExtension;
use Drupal\Core\Url;
use Drupal\Tests\UnitTestCase;
use Prophecy\Prophet;
use Twig\Environment;
use Twig\Loader\ArrayLoader;
use Twig\Loader\FilesystemLoader;
use Twig\Node\Expression\FilterExpression;
use Twig\Source;
class TwigExtensionTest extends UnitTestCase {
protected $renderer;
protected $urlGenerator;
protected $themeManager;
protected $dateFormatter;
protected $systemUnderTest;
protected $fileUrlGenerator;
protected function setUp() : void {
parent::setUp();
$this->renderer = $this
->createMock('\\Drupal\\Core\\Render\\RendererInterface');
$this->urlGenerator = $this
->createMock('\\Drupal\\Core\\Routing\\UrlGeneratorInterface');
$this->themeManager = $this
->createMock('\\Drupal\\Core\\Theme\\ThemeManagerInterface');
$this->dateFormatter = $this
->createMock('\\Drupal\\Core\\Datetime\\DateFormatterInterface');
$this->fileUrlGenerator = $this
->createMock(FileUrlGeneratorInterface::class);
$this->systemUnderTest = new TwigExtension($this->renderer, $this->urlGenerator, $this->themeManager, $this->dateFormatter, $this->fileUrlGenerator);
}
public function testEscaping($template, $expected) {
$loader = new FilesystemLoader();
$twig = new Environment($loader, [
'debug' => TRUE,
'cache' => FALSE,
'autoescape' => 'html',
'optimizations' => 0,
]);
$twig
->addExtension($this->systemUnderTest);
$name = '__string_template_test__';
$nodes = $twig
->parse($twig
->tokenize(new Source($template, $name)));
$this
->assertSame($expected, $nodes
->getNode('body')
->getNode('0')
->getNode('expr') instanceof FilterExpression);
}
public static function providerTestEscaping() {
return [
[
'{{ path("foo") }}',
FALSE,
],
[
'{{ path("foo", {}) }}',
FALSE,
],
[
'{{ path("foo", { foo: "foo" }) }}',
FALSE,
],
[
'{{ path("foo", foo) }}',
TRUE,
],
[
'{{ path("foo", { foo: foo }) }}',
TRUE,
],
[
'{{ path("foo", { foo: ["foo", "bar"] }) }}',
TRUE,
],
[
'{{ path("foo", { foo: "foo", bar: "bar" }) }}',
TRUE,
],
[
'{{ path(name = "foo", parameters = {}) }}',
FALSE,
],
[
'{{ path(name = "foo", parameters = { foo: "foo" }) }}',
FALSE,
],
[
'{{ path(name = "foo", parameters = foo) }}',
TRUE,
],
[
'{{ path(name = "foo", parameters = { foo: ["foo", "bar"] }) }}',
TRUE,
],
[
'{{ path(name = "foo", parameters = { foo: foo }) }}',
TRUE,
],
[
'{{ path(name = "foo", parameters = { foo: "foo", bar: "bar" }) }}',
TRUE,
],
];
}
public function testActiveTheme() {
$active_theme = $this
->getMockBuilder('\\Drupal\\Core\\Theme\\ActiveTheme')
->disableOriginalConstructor()
->getMock();
$active_theme
->expects($this
->once())
->method('getName')
->willReturn('test_theme');
$this->themeManager
->expects($this
->once())
->method('getActiveTheme')
->willReturn($active_theme);
$loader = new StringLoader();
$twig = new Environment($loader);
$twig
->addExtension($this->systemUnderTest);
$result = $twig
->render('{{ active_theme() }}');
$this
->assertEquals('test_theme', $result);
}
public function testFormatDate() {
$this->dateFormatter
->expects($this
->exactly(1))
->method('format')
->willReturnCallback(function ($timestamp) {
return date('Y-m-d', $timestamp);
});
$loader = new StringLoader();
$twig = new Environment($loader);
$twig
->addExtension($this->systemUnderTest);
$timestamp = strtotime('1978-11-19');
$result = $twig
->render('{{ time|format_date("html_date") }}', [
'time' => $timestamp,
]);
$this
->assertEquals('1978-11-19', $result);
}
public function testFileUrl() {
$this->fileUrlGenerator
->expects($this
->once())
->method('generateString')
->with('public://picture.jpg')
->willReturn('sites/default/files/picture.jpg');
$loader = new StringLoader();
$twig = new Environment($loader);
$twig
->addExtension($this->systemUnderTest);
$result = $twig
->render('{{ file_url(file) }}', [
'file' => 'public://picture.jpg',
]);
$this
->assertEquals('sites/default/files/picture.jpg', $result);
}
public function testActiveThemePath() {
$active_theme = $this
->getMockBuilder('\\Drupal\\Core\\Theme\\ActiveTheme')
->disableOriginalConstructor()
->getMock();
$active_theme
->expects($this
->once())
->method('getPath')
->willReturn('foo/bar');
$this->themeManager
->expects($this
->once())
->method('getActiveTheme')
->willReturn($active_theme);
$loader = new StringLoader();
$twig = new Environment($loader);
$twig
->addExtension($this->systemUnderTest);
$result = $twig
->render('{{ active_theme_path() }}');
$this
->assertEquals('foo/bar', $result);
}
public function testSafeStringEscaping() {
$loader = new FilesystemLoader();
$twig = new Environment($loader, [
'debug' => TRUE,
'cache' => FALSE,
'autoescape' => 'html',
'optimizations' => 0,
]);
$safe_string = $this
->createMock('\\Drupal\\Component\\Render\\MarkupInterface');
$this
->assertSame($safe_string, $this->systemUnderTest
->escapeFilter($twig, $safe_string, 'html', 'UTF-8', TRUE));
$string_object = new TwigExtensionTestString("<script>alert('here');</script>");
$this
->assertSame('<script>alert('here');</script>', $this->systemUnderTest
->escapeFilter($twig, $string_object, 'html', 'UTF-8', TRUE));
}
public function testSafeJoin() {
$this->renderer
->expects($this
->any())
->method('render')
->with([
'#markup' => '<strong>will be rendered</strong>',
'#printed' => FALSE,
])
->willReturn('<strong>will be rendered</strong>');
$twig_environment = $this
->prophesize(TwigEnvironment::class)
->reveal();
$markup = $this
->prophesize(TranslatableMarkup::class);
$markup
->__toString()
->willReturn('<em>will be markup</em>');
$markup = $markup
->reveal();
$items = [
'<em>will be escaped</em>',
$markup,
[
'#markup' => '<strong>will be rendered</strong>',
],
];
$result = $this->systemUnderTest
->safeJoin($twig_environment, $items, '<br/>');
$this
->assertEquals('<em>will be escaped</em><br/><em>will be markup</em><br/><strong>will be rendered</strong>', $result);
$items = new \ArrayObject([
'<em>will be escaped</em>',
$markup,
[
'#markup' => '<strong>will be rendered</strong>',
],
]);
$result = $this->systemUnderTest
->safeJoin($twig_environment, $items, ', ');
$this
->assertEquals('<em>will be escaped</em>, <em>will be markup</em>, <strong>will be rendered</strong>', $result);
$items = NULL;
$result = $this->systemUnderTest
->safeJoin($twig_environment, $items, '<br>');
$this
->assertEmpty($result);
}
public function testRenderVar($result, $input) {
$this->renderer
->expects($this
->any())
->method('render')
->with($result += [
'#printed' => FALSE,
])
->willReturn('Rendered output');
$this
->assertEquals('Rendered output', $this->systemUnderTest
->renderVar($input));
}
public static function providerTestRenderVar() {
$data = [];
$renderable = (new Prophet())
->prophesize(RenderableInterface::class);
$render_array = [
'#type' => 'test',
'#var' => 'giraffe',
];
$renderable
->toRenderable()
->willReturn($render_array);
$data['renderable'] = [
$render_array,
$renderable
->reveal(),
];
return $data;
}
public function testEscapeWithGeneratedLink() {
$loader = new FilesystemLoader();
$twig = new Environment($loader, [
'debug' => TRUE,
'cache' => FALSE,
'autoescape' => 'html',
'optimizations' => 0,
]);
$twig
->addExtension($this->systemUnderTest);
$link = new GeneratedLink();
$link
->setGeneratedLink('<a href="http://example.com"></a>');
$link
->addCacheTags([
'foo',
]);
$link
->addAttachments([
'library' => [
'system/base',
],
]);
$this->renderer
->expects($this
->atLeastOnce())
->method('render')
->with([
"#cache" => [
"contexts" => [],
"tags" => [
"foo",
],
"max-age" => -1,
],
"#attached" => [
'library' => [
'system/base',
],
],
]);
$result = $this->systemUnderTest
->escapeFilter($twig, $link, 'html', NULL, TRUE);
$this
->assertEquals('<a href="http://example.com"></a>', $result);
}
public function testRenderVarWithGeneratedLink() {
$link = new GeneratedLink();
$link
->setGeneratedLink('<a href="http://example.com"></a>');
$link
->addCacheTags([
'foo',
]);
$link
->addAttachments([
'library' => [
'system/base',
],
]);
$this->renderer
->expects($this
->atLeastOnce())
->method('render')
->with([
"#cache" => [
"contexts" => [],
"tags" => [
"foo",
],
"max-age" => -1,
],
"#attached" => [
'library' => [
'system/base',
],
],
]);
$result = $this->systemUnderTest
->renderVar($link);
$this
->assertEquals('<a href="http://example.com"></a>', $result);
}
public function testRenderVarEarlyReturn($expected, $input) {
$result = $this->systemUnderTest
->renderVar($input);
$this
->assertSame($expected, $result);
}
public static function providerTestRenderVarEarlyReturn() {
return [
'null' => [
'',
NULL,
],
'empty array' => [
'',
[],
],
'float zero' => [
0,
0.0,
],
'float non-zero' => [
10.0,
10.0,
],
'int zero' => [
0,
0,
],
'int non-zero' => [
10,
10,
],
'empty string' => [
'',
'',
],
'string' => [
'test',
'test',
],
'FALSE' => [
'',
FALSE,
],
'TRUE' => [
TRUE,
TRUE,
],
];
}
public function testCreateAttribute() {
$name = '__string_template_test_1__';
$loader = new ArrayLoader([
$name => "{% for iteration in iterations %}<div{{ create_attribute(iteration) }}></div>{% endfor %}",
]);
$twig = new Environment($loader);
$twig
->addExtension($this->systemUnderTest);
$iterations = [
[
'class' => [
'kittens',
],
'data-toggle' => 'modal',
'data-lang' => 'es',
],
[
'id' => 'puppies',
'data-value' => 'foo',
'data-lang' => 'en',
],
[],
new Attribute(),
];
$result = $twig
->render($name, [
'iterations' => $iterations,
]);
$expected = '<div class="kittens" data-toggle="modal" data-lang="es"></div><div id="puppies" data-value="foo" data-lang="en"></div><div></div><div></div>';
$this
->assertEquals($expected, $result);
$name = '__string_template_test_2__';
$loader = new ArrayLoader([
$name => "<div{{ create_attribute().addClass('meow') }}></div>",
]);
$twig
->setLoader($loader);
$result = $twig
->render($name);
$expected = '<div class="meow"></div>';
$this
->assertEquals($expected, $result);
}
public function testLinkWithOverriddenAttributes() {
$url = Url::fromRoute('<front>', [], [
'attributes' => [
'class' => [
'foo',
],
],
]);
$build = $this->systemUnderTest
->getLink('test', $url, [
'class' => [
'bar',
],
]);
$this
->assertEquals([
'foo',
'bar',
], $build['#url']
->getOption('attributes')['class']);
}
public function testTwigAddSuggestionFilter($original_render_array, $suggestion, $expected_render_array) {
$processed_render_array = $this->systemUnderTest
->suggestThemeHook($original_render_array, $suggestion);
$this
->assertEquals($expected_render_array, $processed_render_array);
}
public static function providerTestTwigAddSuggestionFilter() : \Iterator {
(yield 'suggestion should be added' => [
[
'#theme' => 'kitten',
'#name' => 'Mila',
],
'cute',
[
'#theme' => [
'kitten__cute',
'kitten',
],
'#name' => 'Mila',
],
]);
(yield 'suggestion should extend existing suggestions' => [
[
'#theme' => 'kitten__stripy',
'#name' => 'Mila',
],
'cute',
[
'#theme' => [
'kitten__stripy__cute',
'kitten__stripy',
],
'#name' => 'Mila',
],
]);
(yield 'suggestion should have highest priority' => [
[
'#theme' => [
'kitten__stripy',
'kitten',
],
'#name' => 'Mila',
],
'cute',
[
'#theme' => [
'kitten__stripy__cute',
'kitten__cute',
'kitten__stripy',
'kitten',
],
'#name' => 'Mila',
],
]);
(yield '#printed should be removed after suggestion was added' => [
[
'#theme' => 'kitten',
'#name' => 'Mila',
'#printed' => TRUE,
],
'cute',
[
'#theme' => [
'kitten__cute',
'kitten',
],
'#name' => 'Mila',
],
]);
(yield 'cache key should be added' => [
[
'#theme' => 'kitten',
'#name' => 'Mila',
'#cache' => [
'keys' => [
'kitten',
],
],
],
'cute',
[
'#theme' => [
'kitten__cute',
'kitten',
],
'#name' => 'Mila',
'#cache' => [
'keys' => [
'kitten',
'cute',
],
],
],
]);
(yield 'null/missing content should be ignored' => [
NULL,
'cute',
NULL,
]);
}
public function testTwigAddClass($element, $classes, $expected_result) {
$processed = $this->systemUnderTest
->addClass($element, $classes);
$this
->assertEquals($expected_result, $processed);
}
public static function providerTestTwigAddClass() : \Iterator {
(yield 'should add a class on element' => [
[
'#type' => 'container',
],
'my-class',
[
'#type' => 'container',
'#attributes' => [
'class' => [
'my-class',
],
],
],
]);
(yield 'should add a class from a array of string keys on element' => [
[
'#type' => 'container',
],
[
'my-class',
],
[
'#type' => 'container',
'#attributes' => [
'class' => [
'my-class',
],
],
],
]);
(yield 'should add a class from a Markup value' => [
[
'#type' => 'container',
],
[
Markup::create('my-class'),
],
[
'#type' => 'container',
'#attributes' => [
'class' => [
'my-class',
],
],
],
]);
(yield '#printed should be removed after class(es) added' => [
[
'#markup' => 'This content is already is rendered',
'#printed' => TRUE,
],
'',
[
'#markup' => 'This content is already is rendered',
'#attributes' => [
'class' => [
'',
],
],
],
]);
}
public function testTwigSetAttribute($element, $key, $value, $expected_result) {
$processed = $this->systemUnderTest
->setAttribute($element, $key, $value);
$this
->assertEquals($expected_result, $processed);
}
public static function providerTestTwigSetAttribute() : \Iterator {
(yield 'should add attributes on element' => [
[
'#theme' => 'image',
],
'title',
'Aloha',
[
'#theme' => 'image',
'#attributes' => [
'title' => 'Aloha',
],
],
]);
(yield 'should merge existing attributes on element' => [
[
'#theme' => 'image',
'#attributes' => [
'title' => 'Aloha',
],
],
'title',
'Bonjour',
[
'#theme' => 'image',
'#attributes' => [
'title' => 'Bonjour',
],
],
]);
(yield 'should add JSON attribute value correctly on element' => [
[
'#type' => 'container',
],
'data-slider',
Json::encode([
'autoplay' => TRUE,
]),
[
'#type' => 'container',
'#attributes' => [
'data-slider' => '{"autoplay":true}',
],
],
]);
(yield '#printed should be removed after setting attribute' => [
[
'#markup' => 'This content is already is rendered',
'#printed' => TRUE,
],
'title',
NULL,
[
'#markup' => 'This content is already is rendered',
'#attributes' => [
'title' => NULL,
],
],
]);
}
}
class TwigExtensionTestString {
protected $string;
public function __construct($string) {
$this->string = $string;
}
public function __toString() {
return $this->string;
}
}