mirror of
https://github.com/silverstripe/silverstripe-framework
synced 2024-10-22 14:05:37 +02:00
462 lines
15 KiB
PHP
462 lines
15 KiB
PHP
<?php
|
|
|
|
namespace SilverStripe\View\Tests;
|
|
|
|
use SilverStripe\Core\Injector\Injector;
|
|
use SilverStripe\Core\Kernel;
|
|
use SilverStripe\Core\TempFolder;
|
|
use SilverStripe\Versioned\Versioned;
|
|
use Psr\SimpleCache\CacheInterface;
|
|
use SilverStripe\Dev\SapphireTest;
|
|
use SilverStripe\Control\Director;
|
|
use SilverStripe\View\SSTemplateParseException;
|
|
use SilverStripe\View\SSViewer;
|
|
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
|
|
use Symfony\Component\Cache\Adapter\NullAdapter;
|
|
use Symfony\Component\Cache\Psr16Cache;
|
|
|
|
// Not actually a data object, we just want a ModelData object that's just for us
|
|
|
|
class SSViewerCacheBlockTest extends SapphireTest
|
|
{
|
|
protected static $extra_dataobjects = [
|
|
SSViewerCacheBlockTest\TestModel::class
|
|
];
|
|
|
|
public static function getExtraDataObjects()
|
|
{
|
|
$classes = parent::getExtraDataObjects();
|
|
|
|
// Add extra classes if versioning is enabled
|
|
if (class_exists(Versioned::class)) {
|
|
$classes[] = SSViewerCacheBlockTest\VersionedModel::class;
|
|
}
|
|
return $classes;
|
|
}
|
|
|
|
/**
|
|
* @var SSViewerCacheBlockTest\TestModel
|
|
*/
|
|
protected $data = null;
|
|
|
|
protected function _reset($cacheOn = true)
|
|
{
|
|
$this->data = new SSViewerCacheBlockTest\TestModel();
|
|
|
|
$cache = null;
|
|
if ($cacheOn) {
|
|
// cache indefinitely
|
|
$cache = new Psr16Cache(new FilesystemAdapter('cacheblock', 0, TempFolder::getTempFolder(BASE_PATH)));
|
|
} else {
|
|
$cache = new Psr16Cache(new NullAdapter());
|
|
}
|
|
|
|
Injector::inst()->registerService($cache, CacheInterface::class . '.cacheblock');
|
|
Injector::inst()->get(CacheInterface::class . '.cacheblock')->clear();
|
|
}
|
|
|
|
protected function _runtemplate($template, $data = null)
|
|
{
|
|
if ($data === null) {
|
|
$data = $this->data;
|
|
}
|
|
if (is_array($data)) {
|
|
$data = $this->data->customise($data);
|
|
}
|
|
|
|
return SSViewer::execute_string($template, $data);
|
|
}
|
|
|
|
public function testParsing()
|
|
{
|
|
|
|
// ** Trivial checks **
|
|
|
|
// Make sure an empty cached block parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% cached %><% end_cached %>'), '');
|
|
|
|
// Make sure an empty cacheblock block parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% cacheblock %><% end_cacheblock %>'), '');
|
|
|
|
// Make sure an empty uncached block parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% uncached %><% end_uncached %>'), '');
|
|
|
|
// ** Argument checks **
|
|
|
|
// Make sure a simple cacheblock parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% cached %>Yay<% end_cached %>'), 'Yay');
|
|
|
|
// Make sure a moderately complicated cacheblock parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% cached \'block\', Foo, "jumping" %>Yay<% end_cached %>'), 'Yay');
|
|
|
|
// Make sure a complicated cacheblock parses
|
|
$this->_reset();
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached \'block\', Foo, Test.Test(4).Test(jumping).Foo %>Yay<% end_cached %>'
|
|
),
|
|
'Yay'
|
|
);
|
|
|
|
// ** Conditional Checks **
|
|
|
|
// Make sure a cacheblock with a simple conditional parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% cached if true %>Yay<% end_cached %>'), 'Yay');
|
|
|
|
// Make sure a cacheblock with a complex conditional parses
|
|
$this->_reset();
|
|
$this->assertEquals($this->_runtemplate('<% cached if Test.Test(yank).Foo %>Yay<% end_cached %>'), 'Yay');
|
|
|
|
// Make sure a cacheblock with a complex conditional and arguments parses
|
|
$this->_reset();
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached Foo, Test.Test(4).Test(jumping).Foo if Test.Test(yank).Foo %>Yay<% end_cached %>'
|
|
),
|
|
'Yay'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test that cacheblocks actually cache
|
|
*/
|
|
public function testBlocksCache()
|
|
{
|
|
// First, run twice without caching, to prove we get two different values
|
|
$this->_reset(false);
|
|
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 1]), '1');
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 2]), '2');
|
|
|
|
// Then twice with caching, should get same result each time
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 1]), '1');
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 2]), '1');
|
|
}
|
|
|
|
/**
|
|
* Test that the cacheblocks invalidate when a flush occurs.
|
|
*/
|
|
public function testBlocksInvalidateOnFlush()
|
|
{
|
|
Director::test('/?flush=1');
|
|
$this->_reset(true);
|
|
|
|
// Generate cached value for foo = 1
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 1]), '1');
|
|
|
|
// Test without flush
|
|
Injector::inst()->get(Kernel::class)->boot();
|
|
Director::test('/');
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 3]), '1');
|
|
|
|
// Test with flush
|
|
Injector::inst()->get(Kernel::class)->boot(true);
|
|
Director::test('/?flush=1');
|
|
$this->assertEquals($this->_runtemplate('<% cached %>$Foo<% end_cached %>', ['Foo' => 2]), '2');
|
|
}
|
|
|
|
public function testVersionedCache()
|
|
{
|
|
if (!class_exists(Versioned::class)) {
|
|
$this->markTestSkipped('testVersionedCache requires Versioned extension');
|
|
}
|
|
$origReadingMode = Versioned::get_reading_mode();
|
|
|
|
// Run without caching in stage to prove data is uncached
|
|
$this->_reset(false);
|
|
Versioned::set_stage(Versioned::DRAFT);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('default');
|
|
$this->assertEquals(
|
|
'default Stage.Stage',
|
|
SSViewer::execute_string('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('first');
|
|
$this->assertEquals(
|
|
'first Stage.Stage',
|
|
SSViewer::execute_string('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
|
|
// Run without caching in live to prove data is uncached
|
|
$this->_reset(false);
|
|
Versioned::set_stage(Versioned::LIVE);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('default');
|
|
$this->assertEquals(
|
|
'default Stage.Live',
|
|
$this->_runtemplate('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('first');
|
|
$this->assertEquals(
|
|
'first Stage.Live',
|
|
$this->_runtemplate('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
|
|
// Then with caching, initially in draft, and then in live, to prove that
|
|
// changing the versioned reading mode doesn't cache between modes, but it does
|
|
// within them
|
|
$this->_reset(true);
|
|
Versioned::set_stage(Versioned::DRAFT);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('default');
|
|
$this->assertEquals(
|
|
'default Stage.Stage',
|
|
$this->_runtemplate('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('first');
|
|
$this->assertEquals(
|
|
'default Stage.Stage', // entropy should be ignored due to caching
|
|
$this->_runtemplate('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
|
|
Versioned::set_stage(Versioned::LIVE);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('first');
|
|
$this->assertEquals(
|
|
'first Stage.Live', // First hit in live, so display current entropy
|
|
$this->_runtemplate('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
$data = new SSViewerCacheBlockTest\VersionedModel();
|
|
$data->setEntropy('second');
|
|
$this->assertEquals(
|
|
'first Stage.Live', // entropy should be ignored due to caching
|
|
$this->_runtemplate('<% cached %>$Inspect<% end_cached %>', $data)
|
|
);
|
|
|
|
Versioned::set_reading_mode($origReadingMode);
|
|
}
|
|
|
|
/**
|
|
* Test that cacheblocks conditionally cache with if
|
|
*/
|
|
public function testBlocksConditionallyCacheWithIf()
|
|
{
|
|
// First, run twice with caching
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals($this->_runtemplate('<% cached if True %>$Foo<% end_cached %>', ['Foo' => 1]), '1');
|
|
$this->assertEquals($this->_runtemplate('<% cached if True %>$Foo<% end_cached %>', ['Foo' => 2]), '1');
|
|
|
|
// Then twice without caching
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals($this->_runtemplate('<% cached if False %>$Foo<% end_cached %>', ['Foo' => 1]), '1');
|
|
$this->assertEquals($this->_runtemplate('<% cached if False %>$Foo<% end_cached %>', ['Foo' => 2]), '2');
|
|
|
|
// Then once cached, once not (and the opposite)
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached if Cache %>$Foo<% end_cached %>',
|
|
['Foo' => 1, 'Cache' => true ]
|
|
),
|
|
'1'
|
|
);
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached if Cache %>$Foo<% end_cached %>',
|
|
['Foo' => 2, 'Cache' => false]
|
|
),
|
|
'2'
|
|
);
|
|
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached if Cache %>$Foo<% end_cached %>',
|
|
['Foo' => 1, 'Cache' => false]
|
|
),
|
|
'1'
|
|
);
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached if Cache %>$Foo<% end_cached %>',
|
|
['Foo' => 2, 'Cache' => true ]
|
|
),
|
|
'2'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test that cacheblocks conditionally cache with unless
|
|
*/
|
|
public function testBlocksConditionallyCacheWithUnless()
|
|
{
|
|
// First, run twice with caching
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached unless False %>$Foo<% end_cached %>',
|
|
['Foo' => 1]
|
|
),
|
|
'1'
|
|
);
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached unless False %>$Foo<% end_cached %>',
|
|
['Foo' => 2]
|
|
),
|
|
'1'
|
|
);
|
|
|
|
// Then twice without caching
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached unless True %>$Foo<% end_cached %>',
|
|
['Foo' => 1]
|
|
),
|
|
'1'
|
|
);
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached unless True %>$Foo<% end_cached %>',
|
|
['Foo' => 2]
|
|
),
|
|
'2'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test that nested uncached blocks work
|
|
*/
|
|
public function testNestedUncachedBlocks()
|
|
{
|
|
// First, run twice with caching, to prove we get the same result back normally
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached %> A $Foo B <% end_cached %>',
|
|
['Foo' => 1]
|
|
),
|
|
' A 1 B '
|
|
);
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached %> A $Foo B <% end_cached %>',
|
|
['Foo' => 2]
|
|
),
|
|
' A 1 B '
|
|
);
|
|
|
|
// Then add uncached to the nested block
|
|
$this->_reset(true);
|
|
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached %> A <% uncached %>$Foo<% end_uncached %> B <% end_cached %>',
|
|
['Foo' => 1]
|
|
),
|
|
' A 1 B '
|
|
);
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
'<% cached %> A <% uncached %>$Foo<% end_uncached %> B <% end_cached %>',
|
|
['Foo' => 2]
|
|
),
|
|
' A 2 B '
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Test that nested blocks with different keys works
|
|
*/
|
|
public function testNestedBlocks()
|
|
{
|
|
$this->_reset(true);
|
|
|
|
$template = '<% cached Foo %> $Fooa <% cached Bar %>$Bara<% end_cached %> $Foob <% end_cached %>';
|
|
|
|
// Do it the first time to load the cache
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
$template,
|
|
['Foo' => 1, 'Fooa' => 1, 'Foob' => 3, 'Bar' => 1, 'Bara' => 2]
|
|
),
|
|
' 1 2 3 '
|
|
);
|
|
|
|
// Do it again, the input values are ignored as the cache is hit for both elements
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
$template,
|
|
['Foo' => 1, 'Fooa' => 9, 'Foob' => 9, 'Bar' => 1, 'Bara' => 9]
|
|
),
|
|
' 1 2 3 '
|
|
);
|
|
|
|
// Do it again with a new key for Bar, Bara is picked up, Fooa and Foob are not
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
$template,
|
|
['Foo' => 1, 'Fooa' => 9, 'Foob' => 9, 'Bar' => 2, 'Bara' => 9]
|
|
),
|
|
' 1 9 3 '
|
|
);
|
|
|
|
// Do it again with a new key for Foo, Fooa and Foob are picked up, Bara are not
|
|
$this->assertEquals(
|
|
$this->_runtemplate(
|
|
$template,
|
|
['Foo' => 2, 'Fooa' => 9, 'Foob' => 9, 'Bar' => 2, 'Bara' => 1]
|
|
),
|
|
' 9 9 9 '
|
|
);
|
|
}
|
|
|
|
public function testNoErrorMessageForControlWithinCached()
|
|
{
|
|
$this->_reset(true);
|
|
$this->assertNotNull($this->_runtemplate('<% cached %><% with Foo %>$Bar<% end_with %><% end_cached %>'));
|
|
}
|
|
|
|
public function testErrorMessageForCachedWithinControlWithinCached()
|
|
{
|
|
$this->expectException(SSTemplateParseException::class);
|
|
$this->_reset(true);
|
|
$this->_runtemplate(
|
|
'<% cached %><% with Foo %><% cached %>$Bar<% end_cached %><% end_with %><% end_cached %>'
|
|
);
|
|
}
|
|
|
|
public function testNoErrorMessageForCachedWithinControlWithinUncached()
|
|
{
|
|
$this->_reset(true);
|
|
$this->assertNotNull(
|
|
$this->_runtemplate(
|
|
'<% uncached %><% with Foo %><% cached %>$Bar<% end_cached %><% end_with %><% end_uncached %>'
|
|
)
|
|
);
|
|
}
|
|
|
|
public function testErrorMessageForCachedWithinIf()
|
|
{
|
|
$this->expectException(SSTemplateParseException::class);
|
|
$this->_reset(true);
|
|
$this->_runtemplate('<% cached %><% if Foo %><% cached %>$Bar<% end_cached %><% end_if %><% end_cached %>');
|
|
}
|
|
|
|
public function testErrorMessageForInvalidConditional()
|
|
{
|
|
$this->expectException(SSTemplateParseException::class);
|
|
$this->_reset(true);
|
|
$this->_runtemplate('<% cached Foo if %>$Bar<% end_cached %>');
|
|
}
|
|
}
|