class AliasManagerTest
Same name in other branches
- 9 core/modules/path_alias/tests/src/Unit/AliasManagerTest.php \Drupal\Tests\path_alias\Unit\AliasManagerTest
- 10 core/modules/path_alias/tests/src/Unit/AliasManagerTest.php \Drupal\Tests\path_alias\Unit\AliasManagerTest
- 11.x core/modules/path_alias/tests/src/Unit/AliasManagerTest.php \Drupal\Tests\path_alias\Unit\AliasManagerTest
@coversDefaultClass \Drupal\path_alias\AliasManager @group path_alias
Hierarchy
- class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses \Drupal\Tests\PhpunitCompatibilityTrait
- class \Drupal\Tests\path_alias\Unit\AliasManagerTest extends \Drupal\Tests\UnitTestCase
Expanded class hierarchy of AliasManagerTest
File
-
core/
modules/ path_alias/ tests/ src/ Unit/ AliasManagerTest.php, line 15
Namespace
Drupal\Tests\path_alias\UnitView source
class AliasManagerTest extends UnitTestCase {
/**
* The alias manager.
*
* @var \Drupal\path_alias\AliasManager
*/
protected $aliasManager;
/**
* Alias storage.
*
* @var \Drupal\Core\Path\AliasStorageInterface|\PHPUnit\Framework\MockObject\MockObject
*/
protected $aliasStorage;
/**
* Alias repository.
*
* @var \Drupal\path_alias\AliasRepositoryInterface|\PHPUnit\Framework\MockObject\MockObject
*/
protected $aliasRepository;
/**
* Alias whitelist.
*
* @var \Drupal\path_alias\AliasWhitelistInterface|\PHPUnit\Framework\MockObject\MockObject
*/
protected $aliasWhitelist;
/**
* Language manager.
*
* @var \Drupal\Core\Language\LanguageManagerInterface|\PHPUnit\Framework\MockObject\MockObject
*/
protected $languageManager;
/**
* Cache backend.
*
* @var \Drupal\Core\Cache\CacheBackendInterface|\PHPUnit\Framework\MockObject\MockObject
*/
protected $cache;
/**
* The internal cache key used by the alias manager.
*
* @var string
*/
protected $cacheKey = 'preload-paths:key';
/**
* The cache key passed to the alias manager.
*
* @var string
*/
protected $path = 'key';
/**
* {@inheritdoc}
*/
protected function setUp() {
parent::setUp();
$this->aliasRepository = $this->createMock(AliasRepositoryInterface::class);
$this->aliasWhitelist = $this->createMock('Drupal\\path_alias\\AliasWhitelistInterface');
$this->languageManager = $this->createMock('Drupal\\Core\\Language\\LanguageManagerInterface');
$this->cache = $this->createMock('Drupal\\Core\\Cache\\CacheBackendInterface');
$this->aliasManager = new AliasManager($this->aliasRepository, $this->aliasWhitelist, $this->languageManager, $this->cache);
}
/**
* Tests the getPathByAlias method for an alias that have no matching path.
*
* @covers ::getPathByAlias
*/
public function testGetPathByAliasNoMatch() {
$alias = '/' . $this->randomMachineName();
$language = new Language([
'id' => 'en',
]);
$this->languageManager
->expects($this->any())
->method('getCurrentLanguage')
->with(LanguageInterface::TYPE_URL)
->will($this->returnValue($language));
$this->aliasRepository
->expects($this->once())
->method('lookupByAlias')
->with($alias, $language->getId())
->will($this->returnValue(NULL));
$this->assertEquals($alias, $this->aliasManager
->getPathByAlias($alias));
// Call it twice to test the static cache.
$this->assertEquals($alias, $this->aliasManager
->getPathByAlias($alias));
}
/**
* Tests the getPathByAlias method for an alias that have a matching path.
*
* @covers ::getPathByAlias
*/
public function testGetPathByAliasMatch() {
$alias = $this->randomMachineName();
$path = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$this->aliasRepository
->expects($this->once())
->method('lookupByAlias')
->with($alias, $language->getId())
->will($this->returnValue([
'path' => $path,
]));
$this->assertEquals($path, $this->aliasManager
->getPathByAlias($alias));
// Call it twice to test the static cache.
$this->assertEquals($path, $this->aliasManager
->getPathByAlias($alias));
}
/**
* Tests the getPathByAlias method when a langcode is passed explicitly.
*
* @covers ::getPathByAlias
*/
public function testGetPathByAliasLangcode() {
$alias = $this->randomMachineName();
$path = $this->randomMachineName();
$this->languageManager
->expects($this->never())
->method('getCurrentLanguage');
$this->aliasRepository
->expects($this->once())
->method('lookupByAlias')
->with($alias, 'de')
->will($this->returnValue([
'path' => $path,
]));
$this->assertEquals($path, $this->aliasManager
->getPathByAlias($alias, 'de'));
// Call it twice to test the static cache.
$this->assertEquals($path, $this->aliasManager
->getPathByAlias($alias, 'de'));
}
/**
* Tests the getAliasByPath method for a path that is not in the whitelist.
*
* @covers ::getAliasByPath
*/
public function testGetAliasByPathWhitelist() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$this->setUpCurrentLanguage();
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(FALSE));
// The whitelist returns FALSE for that path part, so the storage should
// never be called.
$this->aliasRepository
->expects($this->never())
->method('lookupBySystemPath');
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
}
/**
* Tests the getAliasByPath method for a path that has no matching alias.
*
* @covers ::getAliasByPath
*/
public function testGetAliasByPathNoMatch() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$language = $this->setUpCurrentLanguage();
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
$this->aliasRepository
->expects($this->once())
->method('lookupBySystemPath')
->with($path, $language->getId())
->will($this->returnValue(NULL));
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
// This needs to write out the cache.
$this->cache
->expects($this->once())
->method('set')
->with($this->cacheKey, [
$language->getId() => [
$path,
],
], (int) $_SERVER['REQUEST_TIME'] + 60 * 60 * 24);
$this->aliasManager
->writeCache();
}
/**
* Tests the getAliasByPath method for a path that has a matching alias.
*
* @covers ::getAliasByPath
* @covers ::writeCache
*/
public function testGetAliasByPathMatch() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$alias = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
$this->aliasRepository
->expects($this->once())
->method('lookupBySystemPath')
->with($path, $language->getId())
->will($this->returnValue([
'alias' => $alias,
]));
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path));
// This needs to write out the cache.
$this->cache
->expects($this->once())
->method('set')
->with($this->cacheKey, [
$language->getId() => [
$path,
],
], (int) $_SERVER['REQUEST_TIME'] + 60 * 60 * 24);
$this->aliasManager
->writeCache();
}
/**
* Tests the getAliasByPath method for a path that is preloaded.
*
* @covers ::getAliasByPath
* @covers ::writeCache
*/
public function testGetAliasByPathCachedMatch() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$alias = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$cached_paths = [
$language->getId() => [
$path,
],
];
$this->cache
->expects($this->once())
->method('get')
->with($this->cacheKey)
->will($this->returnValue((object) [
'data' => $cached_paths,
]));
// Simulate a request so that the preloaded paths are fetched.
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
$this->aliasRepository
->expects($this->once())
->method('preloadPathAlias')
->with($cached_paths[$language->getId()], $language->getId())
->will($this->returnValue([
$path => $alias,
]));
// LookupPathAlias should not be called.
$this->aliasRepository
->expects($this->never())
->method('lookupBySystemPath');
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path));
// This must not write to the cache again.
$this->cache
->expects($this->never())
->method('set');
$this->aliasManager
->writeCache();
}
/**
* Tests the getAliasByPath cache when a different language is requested.
*
* @covers ::getAliasByPath
* @covers ::writeCache
*/
public function testGetAliasByPathCachedMissLanguage() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$alias = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$cached_language = new Language([
'id' => 'de',
]);
$cached_paths = [
$cached_language->getId() => [
$path,
],
];
$this->cache
->expects($this->once())
->method('get')
->with($this->cacheKey)
->will($this->returnValue((object) [
'data' => $cached_paths,
]));
// Simulate a request so that the preloaded paths are fetched.
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
// The requested language is different than the cached, so this will
// need to load.
$this->aliasRepository
->expects($this->never())
->method('preloadPathAlias');
$this->aliasRepository
->expects($this->once())
->method('lookupBySystemPath')
->with($path, $language->getId())
->will($this->returnValue([
'alias' => $alias,
]));
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path));
// There is already a cache entry, so this should not write out to the
// cache.
$this->cache
->expects($this->never())
->method('set');
$this->aliasManager
->writeCache();
}
/**
* Tests the getAliasByPath cache with a preloaded path without alias.
*
* @covers ::getAliasByPath
* @covers ::writeCache
*/
public function testGetAliasByPathCachedMissNoAlias() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$cached_path = $this->randomMachineName();
$cached_alias = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$cached_paths = [
$language->getId() => [
$cached_path,
$path,
],
];
$this->cache
->expects($this->once())
->method('get')
->with($this->cacheKey)
->will($this->returnValue((object) [
'data' => $cached_paths,
]));
// Simulate a request so that the preloaded paths are fetched.
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
$this->aliasRepository
->expects($this->once())
->method('preloadPathAlias')
->with($cached_paths[$language->getId()], $language->getId())
->will($this->returnValue([
$cached_path => $cached_alias,
]));
// LookupPathAlias() should not be called.
$this->aliasRepository
->expects($this->never())
->method('lookupBySystemPath');
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
// This must not write to the cache again.
$this->cache
->expects($this->never())
->method('set');
$this->aliasManager
->writeCache();
}
/**
* Tests the getAliasByPath cache with an unpreloaded path without alias.
*
* @covers ::getAliasByPath
* @covers ::writeCache
*/
public function testGetAliasByPathUncachedMissNoAlias() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$cached_path = $this->randomMachineName();
$cached_alias = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$cached_paths = [
$language->getId() => [
$cached_path,
],
];
$this->cache
->expects($this->once())
->method('get')
->with($this->cacheKey)
->will($this->returnValue((object) [
'data' => $cached_paths,
]));
// Simulate a request so that the preloaded paths are fetched.
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
$this->aliasRepository
->expects($this->once())
->method('preloadPathAlias')
->with($cached_paths[$language->getId()], $language->getId())
->will($this->returnValue([
$cached_path => $cached_alias,
]));
$this->aliasRepository
->expects($this->once())
->method('lookupBySystemPath')
->with($path, $language->getId())
->will($this->returnValue(NULL));
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($path, $this->aliasManager
->getAliasByPath($path));
// There is already a cache entry, so this should not write out to the
// cache.
$this->cache
->expects($this->never())
->method('set');
$this->aliasManager
->writeCache();
}
/**
* @covers ::cacheClear
*/
public function testCacheClear() {
$path = '/path';
$alias = '/alias';
$language = $this->setUpCurrentLanguage();
$this->aliasRepository
->expects($this->exactly(2))
->method('lookupBySystemPath')
->with($path, $language->getId())
->willReturn([
'alias' => $alias,
]);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->willReturn(TRUE);
// Populate the lookup map.
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path, $language->getId()));
// Check that the cache is populated.
$this->aliasRepository
->expects($this->never())
->method('lookupByAlias');
$this->assertEquals($path, $this->aliasManager
->getPathByAlias($alias, $language->getId()));
// Clear specific source.
$this->cache
->expects($this->exactly(2))
->method('delete');
$this->aliasManager
->cacheClear($path);
// Ensure cache has been cleared (this will be the 2nd call to
// `lookupPathAlias` if cache is cleared).
$this->assertEquals($alias, $this->aliasManager
->getAliasByPath($path, $language->getId()));
// Clear non-existent source.
$this->aliasManager
->cacheClear('non-existent');
}
/**
* Tests the getAliasByPath cache with an unpreloaded path with alias.
*
* @covers ::getAliasByPath
* @covers ::writeCache
*/
public function testGetAliasByPathUncachedMissWithAlias() {
$path_part1 = $this->randomMachineName();
$path_part2 = $this->randomMachineName();
$path = '/' . $path_part1 . '/' . $path_part2;
$cached_path = $this->randomMachineName();
$cached_no_alias_path = $this->randomMachineName();
$cached_alias = $this->randomMachineName();
$new_alias = $this->randomMachineName();
$language = $this->setUpCurrentLanguage();
$cached_paths = [
$language->getId() => [
$cached_path,
$cached_no_alias_path,
],
];
$this->cache
->expects($this->once())
->method('get')
->with($this->cacheKey)
->will($this->returnValue((object) [
'data' => $cached_paths,
]));
// Simulate a request so that the preloaded paths are fetched.
$this->aliasManager
->setCacheKey($this->path);
$this->aliasWhitelist
->expects($this->any())
->method('get')
->with($path_part1)
->will($this->returnValue(TRUE));
$this->aliasRepository
->expects($this->once())
->method('preloadPathAlias')
->with($cached_paths[$language->getId()], $language->getId())
->will($this->returnValue([
$cached_path => $cached_alias,
]));
$this->aliasRepository
->expects($this->once())
->method('lookupBySystemPath')
->with($path, $language->getId())
->will($this->returnValue([
'alias' => $new_alias,
]));
$this->assertEquals($new_alias, $this->aliasManager
->getAliasByPath($path));
// Call it twice to test the static cache.
$this->assertEquals($new_alias, $this->aliasManager
->getAliasByPath($path));
// There is already a cache entry, so this should not write out to the
// cache.
$this->cache
->expects($this->never())
->method('set');
$this->aliasManager
->writeCache();
}
/**
* Sets up the current language.
*
* @return \Drupal\Core\Language\LanguageInterface
* The current language object.
*/
protected function setUpCurrentLanguage() {
$language = new Language([
'id' => 'en',
]);
$this->languageManager
->expects($this->any())
->method('getCurrentLanguage')
->with(LanguageInterface::TYPE_URL)
->will($this->returnValue($language));
return $language;
}
}
Members
Title Sort descending | Deprecated | Modifiers | Object type | Summary | Overriden Title | Overrides |
---|---|---|---|---|---|---|
AliasManagerTest::$aliasManager | protected | property | The alias manager. | |||
AliasManagerTest::$aliasRepository | protected | property | Alias repository. | |||
AliasManagerTest::$aliasStorage | protected | property | Alias storage. | |||
AliasManagerTest::$aliasWhitelist | protected | property | Alias whitelist. | |||
AliasManagerTest::$cache | protected | property | Cache backend. | |||
AliasManagerTest::$cacheKey | protected | property | The internal cache key used by the alias manager. | |||
AliasManagerTest::$languageManager | protected | property | Language manager. | |||
AliasManagerTest::$path | protected | property | The cache key passed to the alias manager. | |||
AliasManagerTest::setUp | protected | function | Overrides UnitTestCase::setUp | |||
AliasManagerTest::setUpCurrentLanguage | protected | function | Sets up the current language. | |||
AliasManagerTest::testCacheClear | public | function | @covers ::cacheClear | |||
AliasManagerTest::testGetAliasByPathCachedMatch | public | function | Tests the getAliasByPath method for a path that is preloaded. | |||
AliasManagerTest::testGetAliasByPathCachedMissLanguage | public | function | Tests the getAliasByPath cache when a different language is requested. | |||
AliasManagerTest::testGetAliasByPathCachedMissNoAlias | public | function | Tests the getAliasByPath cache with a preloaded path without alias. | |||
AliasManagerTest::testGetAliasByPathMatch | public | function | Tests the getAliasByPath method for a path that has a matching alias. | |||
AliasManagerTest::testGetAliasByPathNoMatch | public | function | Tests the getAliasByPath method for a path that has no matching alias. | |||
AliasManagerTest::testGetAliasByPathUncachedMissNoAlias | public | function | Tests the getAliasByPath cache with an unpreloaded path without alias. | |||
AliasManagerTest::testGetAliasByPathUncachedMissWithAlias | public | function | Tests the getAliasByPath cache with an unpreloaded path with alias. | |||
AliasManagerTest::testGetAliasByPathWhitelist | public | function | Tests the getAliasByPath method for a path that is not in the whitelist. | |||
AliasManagerTest::testGetPathByAliasLangcode | public | function | Tests the getPathByAlias method when a langcode is passed explicitly. | |||
AliasManagerTest::testGetPathByAliasMatch | public | function | Tests the getPathByAlias method for an alias that have a matching path. | |||
AliasManagerTest::testGetPathByAliasNoMatch | public | function | Tests the getPathByAlias method for an alias that have no matching path. | |||
PhpunitCompatibilityTrait::getMock | Deprecated | public | function | Returns a mock object for the specified class using the available method. | ||
PhpunitCompatibilityTrait::setExpectedException | Deprecated | public | function | Compatibility layer for PHPUnit 6 to support PHPUnit 4 code. | ||
UnitTestCase::$randomGenerator | protected | property | The random generator. | |||
UnitTestCase::$root | protected | property | The app root. | 1 | ||
UnitTestCase::assertArrayEquals | protected | function | Asserts if two arrays are equal by sorting them first. | |||
UnitTestCase::getBlockMockWithMachineName | Deprecated | protected | function | Mocks a block with a block plugin. | 1 | |
UnitTestCase::getClassResolverStub | protected | function | Returns a stub class resolver. | |||
UnitTestCase::getConfigFactoryStub | public | function | Returns a stub config factory that behaves according to the passed array. | |||
UnitTestCase::getConfigStorageStub | public | function | Returns a stub config storage that returns the supplied configuration. | |||
UnitTestCase::getContainerWithCacheTagsInvalidator | protected | function | Sets up a container with a cache tags invalidator. | |||
UnitTestCase::getRandomGenerator | protected | function | Gets the random generator for the utility methods. | |||
UnitTestCase::getStringTranslationStub | public | function | Returns a stub translation manager that just returns the passed string. | |||
UnitTestCase::randomMachineName | public | function | Generates a unique random string containing letters and numbers. |
Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.