tests/IntegrationTest.php
36372c61
 <?php
 
2119e60c
 namespace Twig\Tests;
 
36372c61
 /*
  * This file is part of Twig.
  *
  * (c) Fabien Potencier
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
 
90d579e4
 use Twig\Extension\AbstractExtension;
 use Twig\Extension\DebugExtension;
 use Twig\Extension\SandboxExtension;
 use Twig\Extension\StringLoaderExtension;
 use Twig\Node\Expression\ConstantExpression;
54cec4e3
 use Twig\Node\Node;
90d579e4
 use Twig\Node\PrintNode;
 use Twig\Sandbox\SecurityPolicy;
 use Twig\Test\IntegrationTestCase;
 use Twig\Token;
 use Twig\TokenParser\AbstractTokenParser;
 use Twig\TwigFilter;
 use Twig\TwigFunction;
 use Twig\TwigTest;
 
36372c61
 // This function is defined to check that escaping strategies
 // like html works even if a function with the same name is defined.
 function html()
 {
     return 'foo';
 }
 
2119e60c
 class IntegrationTest extends IntegrationTestCase
36372c61
 {
     public function getExtensions()
     {
e24f796b
         $policy = new SecurityPolicy([], [], [], [], ['dump']);
36372c61
 
5c55243d
         return [
90d579e4
             new DebugExtension(),
             new SandboxExtension($policy, false),
             new StringLoaderExtension(),
36372c61
             new TwigTestExtension(),
5c55243d
         ];
36372c61
     }
 
     public function getFixturesDir()
     {
f0a81e0e
         return __DIR__.'/Fixtures/';
36372c61
     }
 }
 
 function test_foo($value = 'foo')
 {
     return $value;
 }
 
010cfaf4
 class TwigTestFoo implements \Iterator
36372c61
 {
     const BAR_NAME = 'bar';
 
     public $position = 0;
5c55243d
     public $array = [1, 2];
36372c61
 
     public function bar($param1 = null, $param2 = null)
     {
         return 'bar'.($param1 ? '_'.$param1 : '').($param2 ? '-'.$param2 : '');
     }
 
     public function getFoo()
     {
         return 'foo';
     }
 
     public function getSelf()
     {
         return $this;
     }
 
     public function is()
     {
         return 'is';
     }
 
     public function in()
     {
         return 'in';
     }
 
     public function not()
     {
         return 'not';
     }
 
     public function strToLower($value)
     {
         return strtolower($value);
     }
 
     public function rewind()
     {
         $this->position = 0;
     }
 
     public function current()
     {
         return $this->array[$this->position];
     }
 
     public function key()
     {
         return 'a';
     }
 
     public function next()
     {
         ++$this->position;
     }
 
     public function valid()
     {
         return isset($this->array[$this->position]);
     }
 }
 
90d579e4
 class TwigTestTokenParser_§ extends AbstractTokenParser
36372c61
 {
54cec4e3
     public function parse(Token $token): Node
36372c61
     {
90d579e4
         $this->parser->getStream()->expect(Token::BLOCK_END_TYPE);
36372c61
 
90d579e4
         return new PrintNode(new ConstantExpression('§', -1), -1);
36372c61
     }
 
54cec4e3
     public function getTag(): string
36372c61
     {
c8fe2538
         return '§';
36372c61
     }
 }
 
90d579e4
 class TwigTestExtension extends AbstractExtension
36372c61
 {
54cec4e3
     public function getTokenParsers(): array
36372c61
     {
5c55243d
         return [
c8fe2538
             new TwigTestTokenParser_§(),
5c55243d
         ];
36372c61
     }
 
54cec4e3
     public function getFilters(): array
36372c61
     {
5c55243d
         return [
90d579e4
             new TwigFilter('§', [$this, '§Filter']),
             new TwigFilter('escape_and_nl2br', [$this, 'escape_and_nl2br'], ['needs_environment' => true, 'is_safe' => ['html']]),
             new TwigFilter('nl2br', [$this, 'nl2br'], ['pre_escape' => 'html', 'is_safe' => ['html']]),
             new TwigFilter('escape_something', [$this, 'escape_something'], ['is_safe' => ['something']]),
             new TwigFilter('preserves_safety', [$this, 'preserves_safety'], ['preserves_safety' => ['html']]),
2119e60c
             new TwigFilter('static_call_string', 'Twig\Tests\TwigTestExtension::staticCall'),
             new TwigFilter('static_call_array', ['Twig\Tests\TwigTestExtension', 'staticCall']),
90d579e4
             new TwigFilter('magic_call', [$this, 'magicCall']),
2119e60c
             new TwigFilter('magic_call_string', 'Twig\Tests\TwigTestExtension::magicStaticCall'),
             new TwigFilter('magic_call_array', ['Twig\Tests\TwigTestExtension', 'magicStaticCall']),
90d579e4
             new TwigFilter('*_path', [$this, 'dynamic_path']),
             new TwigFilter('*_foo_*_bar', [$this, 'dynamic_foo']),
5724cbed
             new TwigFilter('not', [$this, 'notFilter']),
90d579e4
             new TwigFilter('anon_foo', function ($name) { return '*'.$name.'*'; }),
5c55243d
         ];
36372c61
     }
 
54cec4e3
     public function getFunctions(): array
36372c61
     {
5c55243d
         return [
90d579e4
             new TwigFunction('§', [$this, '§Function']),
             new TwigFunction('safe_br', [$this, 'br'], ['is_safe' => ['html']]),
             new TwigFunction('unsafe_br', [$this, 'br']),
2119e60c
             new TwigFunction('static_call_string', 'Twig\Tests\TwigTestExtension::staticCall'),
             new TwigFunction('static_call_array', ['Twig\Tests\TwigTestExtension', 'staticCall']),
90d579e4
             new TwigFunction('*_path', [$this, 'dynamic_path']),
             new TwigFunction('*_foo_*_bar', [$this, 'dynamic_foo']),
             new TwigFunction('anon_foo', function ($name) { return '*'.$name.'*'; }),
5c55243d
         ];
36372c61
     }
 
54cec4e3
     public function getTests(): array
0082e052
     {
5c55243d
         return [
90d579e4
             new TwigTest('multi word', [$this, 'is_multi_word']),
             new TwigTest('test_*', [$this, 'dynamic_test']),
5c55243d
         ];
0082e052
     }
 
5724cbed
     public function notFilter($value)
     {
         return 'not '.$value;
     }
 
c8fe2538
     public function §Filter($value)
36372c61
     {
c8fe2538
         return "§{$value}§";
36372c61
     }
 
c8fe2538
     public function §Function($value)
36372c61
     {
c8fe2538
         return "§{$value}§";
36372c61
     }
 
     /**
b0c41d42
      * nl2br which also escapes, for testing escaper filters.
36372c61
      */
     public function escape_and_nl2br($env, $value, $sep = '<br />')
     {
         return $this->nl2br(twig_escape_filter($env, $value, 'html'), $sep);
     }
 
     /**
b0c41d42
      * nl2br only, for testing filters with pre_escape.
36372c61
      */
     public function nl2br($value, $sep = '<br />')
     {
         // not secure if $value contains html tags (not only entities)
         // don't use
         return str_replace("\n", "$sep\n", $value);
     }
 
     public function dynamic_path($element, $item)
     {
         return $element.'/'.$item;
     }
 
     public function dynamic_foo($foo, $bar, $item)
     {
         return $foo.'/'.$bar.'/'.$item;
     }
 
4beb7bfb
     public function dynamic_test($element, $item)
     {
         return $element === $item;
     }
 
36372c61
     public function escape_something($value)
     {
         return strtoupper($value);
     }
 
     public function preserves_safety($value)
     {
         return strtoupper($value);
     }
 
c73e97ec
     public static function staticCall($value)
     {
         return "*$value*";
     }
 
36372c61
     public function br()
     {
         return '<br />';
     }
 
0082e052
     public function is_multi_word($value)
     {
         return false !== strpos($value, ' ');
     }
e01c29be
 
     public function __call($method, $arguments)
     {
         if ('magicCall' !== $method) {
b8daa6c4
             throw new \BadMethodCallException('Unexpected call to __call');
e01c29be
         }
 
         return 'magic_'.$arguments[0];
     }
 
     public static function __callStatic($method, $arguments)
     {
         if ('magicStaticCall' !== $method) {
b8daa6c4
             throw new \BadMethodCallException('Unexpected call to __callStatic');
e01c29be
         }
 
         return 'static_magic_'.$arguments[0];
     }
36372c61
 }
f5193e92
 
 /**
  * This class is used in tests for the "length" filter and "empty" test. It asserts that __call is not
  * used to convert such objects to strings.
  */
 class MagicCallStub
 {
     public function __call($name, $args)
     {
b8daa6c4
         throw new \Exception('__call shall not be called');
f5193e92
     }
 }
 
 class ToStringStub
 {
     /**
      * @var string
      */
     private $string;
 
     public function __construct($string)
     {
         $this->string = $string;
     }
 
     public function __toString()
     {
         return $this->string;
     }
 }
 
 /**
  * This class is used in tests for the length filter and empty test to show
  * that when \Countable is implemented, it is preferred over the __toString()
  * method.
  */
 class CountableStub implements \Countable
 {
     private $count;
 
     public function __construct($count)
     {
         $this->count = $count;
     }
 
     public function count()
     {
         return $this->count;
     }
 
     public function __toString()
     {
b8daa6c4
         throw new \Exception('__toString shall not be called on \Countables');
f5193e92
     }
 }
be2c32cc
 
 /**
caf2caa8
  * This class is used in tests for the length filter.
be2c32cc
  */
 class IteratorAggregateStub implements \IteratorAggregate
 {
     private $data;
 
     public function __construct(array $data)
     {
         $this->data = $data;
     }
 
     public function getIterator()
     {
b8daa6c4
         return new \ArrayIterator($this->data);
be2c32cc
     }
 }
3a32f4a5
 
2119e60c
 class SimpleIteratorForTesting implements \Iterator
3a32f4a5
 {
     private $data = [1, 2, 3, 4, 5, 6, 7];
     private $key = 0;
 
     public function current()
     {
         return $this->key;
     }
 
     public function next()
     {
         ++$this->key;
     }
 
     public function key()
     {
         return $this->key;
     }
 
     public function valid()
     {
         return isset($this->data[$this->key]);
     }
 
     public function rewind()
     {
         $this->key = 0;
     }
 
     public function __toString()
     {
         // for testing, make sure string length returned is not the same as the `iterator_count`
         return str_repeat('X', iterator_count($this) + 10);
     }
 }