class FilteredStorageTest in Config Filter 8.2
Same name and namespace in other branches
- 8 src/Tests/FilteredStorageTest.php \Drupal\config_filter\Tests\FilteredStorageTest
Tests StorageWrapper operations using the CachedStorage.
@group config_filter
Hierarchy
- class \Drupal\KernelTests\KernelTestBase extends \PHPUnit\Framework\TestCase implements ServiceProviderInterface uses AssertContentTrait, AssertLegacyTrait, AssertHelperTrait, ConfigTestTrait, PhpunitCompatibilityTrait, RandomGeneratorTrait, TestRequirementsTrait
- class \Drupal\KernelTests\Core\Config\Storage\ConfigStorageTestBase
- class \Drupal\KernelTests\Core\Config\Storage\CachedStorageTest
- class \Drupal\config_filter\Tests\FilteredStorageTest
- class \Drupal\KernelTests\Core\Config\Storage\CachedStorageTest
- class \Drupal\KernelTests\Core\Config\Storage\ConfigStorageTestBase
Expanded class hierarchy of FilteredStorageTest
File
- src/
Tests/ FilteredStorageTest.php, line 20
Namespace
Drupal\config_filter\TestsView source
class FilteredStorageTest extends CachedStorageTest {
/**
* {@inheritdoc}
*/
protected function setUp() : void {
parent::setUp();
// The storage is a wrapper with a transparent filter.
// So all inherited tests should still pass.
$this->storage = new FilteredStorage($this->storage, [
new TransparentFilter(),
]);
}
/**
* Test that the storage is set on the filters.
*/
public function testSettingStorages() {
/** @var \Drupal\config_filter\Tests\TransparentFilter[] $filters */
$filters = static::getProtectedFilters($this->storage);
foreach ($filters as $filter) {
// Test that the source storage is a ReadonlyStorage and wraps the cached
// storage from the inherited test.
$readonly = $filter
->getPrivateSourceStorage();
$this
->assertInstanceOf(ReadOnlyStorage::class, $readonly);
$readonlyReflection = new \ReflectionClass(ReadOnlyStorage::class);
$storageProperty = $readonlyReflection
->getProperty('storage');
$storageProperty
->setAccessible(TRUE);
$source = $storageProperty
->getValue($readonly);
$this
->assertInstanceOf(CachedStorage::class, $source);
// Assert that the filter gets the storage.
$this
->assertEquals($this->storage, $filter
->getPrivateFilteredStorage());
}
}
/**
* Test that creating collections keeps filters set to the correct storages.
*/
public function testCollectionStorages() {
$collection = $this
->randomString();
// The storage is in its default state.
$this
->assertEquals(StorageInterface::DEFAULT_COLLECTION, $this->storage
->getCollectionName());
/** @var \Drupal\config_filter\Tests\TransparentFilter[] $filters */
$filters = static::getProtectedFilters($this->storage);
foreach ($filters as $filter) {
// Test that the filters have the correct storage set.
$this
->assertEquals($this->storage, $filter
->getPrivateFilteredStorage());
$this
->assertEquals(StorageInterface::DEFAULT_COLLECTION, $filter
->getPrivateSourceStorage()
->getCollectionName());
}
// Create a collection which creates a clone of the storage and filters.
$collectionStorage = $this->storage
->createCollection($collection);
$this
->assertInstanceOf(FilteredStorageInterface::class, $collectionStorage);
/** @var \Drupal\config_filter\Tests\TransparentFilter[] $collectionFilters */
$collectionFilters = static::getProtectedFilters($collectionStorage);
foreach ($collectionFilters as $filter) {
// Test that the cloned filter has the correct storage set.
$this
->assertEquals($collectionStorage, $filter
->getPrivateFilteredStorage());
$this
->assertEquals($collection, $filter
->getPrivateSourceStorage()
->getCollectionName());
}
/** @var \Drupal\config_filter\Tests\TransparentFilter[] $filters */
$filters = static::getProtectedFilters($this->storage);
foreach ($filters as $filter) {
// Test that the filters on the original storage are still correctly set.
$this
->assertEquals($this->storage, $filter
->getPrivateFilteredStorage());
$this
->assertEquals(StorageInterface::DEFAULT_COLLECTION, $filter
->getPrivateSourceStorage()
->getCollectionName());
}
}
/**
* Test setting up filters in FilteredStorage::createCollection().
*/
public function testCreateCollectionFilter() {
$collection = $this
->randomString();
$filteredCollection = $this
->randomString();
$filter = $this
->prophesizeFilter();
$filterC = $this
->prophesizeFilter();
$filterC
->filterGetCollectionName($collection)
->willReturn($filteredCollection);
$filter
->filterCreateCollection($collection)
->willReturn($filterC
->reveal());
$source = $this
->prophesize(StorageInterface::class);
$sourceC = $this
->prophesize(StorageInterface::class);
$sourceC
->getCollectionName()
->willReturn($collection);
$source
->createCollection($collection)
->willReturn($sourceC
->reveal());
$storage = new FilteredStorage($source
->reveal(), [
$filter
->reveal(),
]);
// Creating a collection makes sure the filters were correctly set up.
$storageC = $storage
->createCollection($collection);
// Test that the collection is filtered in the collection storage.
$this
->assertEquals($filteredCollection, $storageC
->getCollectionName());
}
/**
* Test collection names from FilteredStorage::getAllCollectionNames().
*/
public function testGetAllCollectionNamesFilter() {
$source = $this
->prophesize(StorageInterface::class);
$source
->getAllCollectionNames()
->willReturn([
'a',
'b',
]);
$filter = $this
->prophesizeFilter();
$filter
->filterGetAllCollectionNames([
'a',
'b',
])
->willReturn([
'b',
'b',
'c',
]);
$storage = new FilteredStorage($source
->reveal(), [
$filter
->reveal(),
]);
$this
->assertEquals([
'b',
'c',
], $storage
->getAllCollectionNames());
}
/**
* Test the read methods invokes the correct filter methods.
*
* @dataProvider readFilterProvider
*/
public function testReadFilter($name, $storageMethod, $filterMethod, $data, $expected) {
$source = $this
->prophesize(StorageInterface::class);
$filterA = $this
->prophesizeFilter();
$filterB = $this
->prophesizeFilter();
$source
->{$storageMethod}($name)
->willReturn($data);
$interim = $this
->randomArray();
$filterA
->{$filterMethod}($name, $data)
->willReturn($interim);
$filterB
->{$filterMethod}($name, $interim)
->willReturn($expected);
$storage = new FilteredStorage($source
->reveal(), [
$filterA
->reveal(),
$filterB
->reveal(),
]);
$this
->assertEquals($expected, $storage
->{$storageMethod}($name));
}
/**
* Data provider for testReadFilter.
*/
public function readFilterProvider() {
// @codingStandardsIgnoreStart
return [
[
$this
->randomString(),
'exists',
'filterExists',
TRUE,
TRUE,
],
[
$this
->randomString(),
'exists',
'filterExists',
TRUE,
FALSE,
],
[
$this
->randomString(),
'exists',
'filterExists',
FALSE,
TRUE,
],
[
$this
->randomString(),
'exists',
'filterExists',
FALSE,
FALSE,
],
[
$this
->randomString(),
'read',
'filterRead',
$this
->randomArray(),
$this
->randomArray(),
],
[
$this
->randomString(),
'read',
'filterRead',
NULL,
$this
->randomArray(),
],
[
$this
->randomString(),
'read',
'filterRead',
$this
->randomArray(),
NULL,
],
[
[
$this
->randomString(),
$this
->randomString(),
],
'readMultiple',
'filterReadMultiple',
[
$this
->randomArray(),
$this
->randomArray(),
],
[
$this
->randomArray(),
$this
->randomArray(),
],
],
[
[
$this
->randomString(),
$this
->randomString(),
],
'readMultiple',
'filterReadMultiple',
[
$this
->randomArray(),
FALSE,
],
[
$this
->randomArray(),
$this
->randomArray(),
],
],
];
// @codingStandardsIgnoreEnd
}
/**
* Test that when a filter removes config on a readMultiple it is not set.
*/
public function testReadMultipleWithEmptyResults() {
$names = [
$this
->randomString(),
$this
->randomString(),
];
$source = $this
->prophesize(StorageInterface::class);
$data = [
$this
->randomArray(),
$this
->randomArray(),
];
$source
->readMultiple($names)
->willReturn($data);
$source = $source
->reveal();
foreach ([
0,
[],
NULL,
] as $none) {
$filtered = $data;
$filtered[1] = $none;
$filter = $this
->prophesizeFilter();
$filter
->filterReadMultiple($names, $data)
->willReturn($filtered);
$storage = new FilteredStorage($source, [
$filter
->reveal(),
]);
$this
->assertEquals([
$data[0],
], $storage
->readMultiple($names));
}
}
/**
* Test the write method invokes the filterWrite in filters.
*
* @dataProvider writeFilterProvider
*/
public function testWriteFilter($interim, $expected, $exists = TRUE) {
$name = $this
->randomString();
$data = $this
->randomArray();
$source = $this
->prophesize(StorageInterface::class);
$filterA = $this
->prophesizeFilter();
$filterB = $this
->prophesizeFilter();
$filterA
->filterWrite($name, $data)
->willReturn($interim);
$interim = is_array($interim) ? $interim : [];
$filterB
->filterWrite($name, $interim)
->willReturn($expected);
if ($expected) {
$source
->write($name, $expected)
->willReturn(TRUE);
}
else {
$source
->write(Argument::any())
->shouldNotBeCalled();
$source
->exists($name)
->willReturn($exists);
if ($exists) {
$filterA
->filterWriteEmptyIsDelete($name)
->willReturn(TRUE);
$source
->delete($name)
->willReturn(TRUE);
}
}
$storage = new FilteredStorage($source
->reveal(), [
$filterA
->reveal(),
$filterB
->reveal(),
]);
$this
->assertTrue($storage
->write($name, $data));
}
/**
* Data provider for testWriteFilter.
*/
public function writeFilterProvider() {
return [
[
$this
->randomArray(),
$this
->randomArray(),
],
[
NULL,
$this
->randomArray(),
],
[
[],
$this
->randomArray(),
],
[
$this
->randomArray(),
NULL,
FALSE,
],
[
$this
->randomArray(),
[],
FALSE,
],
[
$this
->randomArray(),
NULL,
TRUE,
],
];
}
/**
* Test the delete method invokes the filterDelete in filters.
*
* @dataProvider deleteFilterProvider
*/
public function testDeleteFilter($interim, $expected) {
$name = $this
->randomString();
$source = $this
->prophesize(StorageInterface::class);
$filterA = $this
->prophesizeFilter();
$filterB = $this
->prophesizeFilter();
$filterA
->filterDelete($name, TRUE)
->willReturn($interim);
$filterB
->filterDelete($name, $interim)
->willReturn($expected);
if ($expected) {
$source
->delete($name)
->willReturn(TRUE);
}
else {
$source
->delete(Argument::any())
->shouldNotBeCalled();
}
$storage = new FilteredStorage($source
->reveal(), [
$filterA
->reveal(),
$filterB
->reveal(),
]);
$this
->assertEquals($expected, $storage
->delete($name));
}
/**
* Data provider for testDeleteFilter.
*/
public function deleteFilterProvider() {
return [
[
TRUE,
TRUE,
],
[
FALSE,
TRUE,
],
[
TRUE,
FALSE,
],
[
FALSE,
FALSE,
],
];
}
/**
* Test the rename method invokes the filterRename in filters.
*
* @dataProvider renameFilterProvider
*/
public function testRenameFilter($interim, $expected) {
$name = $this
->randomString();
$name2 = $this
->randomString();
$source = $this
->prophesize(StorageInterface::class);
$filterA = $this
->prophesizeFilter();
$filterB = $this
->prophesizeFilter();
$filterA
->filterRename($name, $name2, TRUE)
->willReturn($interim);
$filterB
->filterRename($name, $name2, $interim)
->willReturn($expected);
if ($expected) {
$source
->rename($name, $name2)
->willReturn(TRUE);
}
else {
$source
->rename(Argument::any())
->shouldNotBeCalled();
}
$storage = new FilteredStorage($source
->reveal(), [
$filterA
->reveal(),
$filterB
->reveal(),
]);
$this
->assertEquals($expected, $storage
->rename($name, $name2));
}
/**
* Data provider for testRenameFilter.
*/
public function renameFilterProvider() {
return [
[
TRUE,
TRUE,
],
[
FALSE,
TRUE,
],
[
TRUE,
FALSE,
],
[
FALSE,
FALSE,
],
];
}
/**
* Test the deleteAll method invokes the filterDeleteAll in filters.
*
* @dataProvider deleteAllFilterProvider
*/
public function testDeleteAllFilter($interim, $expected) {
$name = $this
->randomString();
$source = $this
->prophesize(StorageInterface::class);
$filterA = $this
->prophesizeFilter();
$filterB = $this
->prophesizeFilter();
$filterA
->filterDeleteAll($name, TRUE)
->willReturn($interim);
$filterB
->filterDeleteAll($name, $interim)
->willReturn($expected);
if ($expected) {
$source
->deleteAll($name)
->willReturn(TRUE);
}
else {
$source
->deleteAll(Argument::any())
->shouldNotBeCalled();
$all = [
$this
->randomString(),
$this
->randomString(),
];
$source
->listAll($name)
->willReturn($all);
foreach ($all as $item) {
$filterA
->filterDelete($item, TRUE)
->willReturn(TRUE);
$filterB
->filterDelete($item, TRUE)
->willReturn(FALSE);
}
}
$storage = new FilteredStorage($source
->reveal(), [
$filterA
->reveal(),
$filterB
->reveal(),
]);
$this
->assertTrue($storage
->deleteAll($name));
}
/**
* Data provider for testDeleteAllFilter.
*/
public function deleteAllFilterProvider() {
return [
[
TRUE,
TRUE,
],
[
FALSE,
TRUE,
],
[
TRUE,
FALSE,
],
[
FALSE,
FALSE,
],
];
}
/**
* Test that an exception is thrown when invalid arguments are passed.
*/
public function testInvalidStorageFilterArgument() {
$source = $this
->prophesize(StorageInterface::class);
// We would do this with $this->expectException but alas drupal is stuck on
// phpunit 4 and we try not to add deprecated code.
try {
new FilteredStorage($source
->reveal(), [
new \stdClass(),
]);
$this
->fail('An exception should have been thrown.');
} catch (InvalidStorageFilterException $exception) {
$this
->assertTrue(TRUE);
}
}
/**
* Prophesize a StorageFilter.
*/
protected function prophesizeFilter() {
$filter = $this
->prophesize(StorageFilterInterface::class);
$filter
->setSourceStorage(Argument::type(ReadOnlyStorage::class))
->shouldBeCalledTimes(1);
$filter
->setFilteredStorage(Argument::type(FilteredStorage::class))
->shouldBeCalledTimes(1);
return $filter;
}
/**
* Get the filters from a FilteredStorageInterface.
*
* @param \Drupal\Core\Config\StorageInterface $storage
* The storage with the protected filters property.
*
* @return \Drupal\config_filter\Config\StorageFilterInterface[]
* The array of filters.
*/
protected static function getProtectedFilters(StorageInterface $storage) {
$filterReflection = new \ReflectionClass(FilteredStorage::class);
$filtersProperty = $filterReflection
->getProperty('filters');
$filtersProperty
->setAccessible(TRUE);
return $filtersProperty
->getValue($storage);
}
/**
* Create a random array.
*/
protected function randomArray($size = 4) {
return (array) $this
->randomObject($size);
}
}
Members
Name![]() |
Modifiers | Type | Description | Overrides |
---|---|---|---|---|
AssertContentTrait:: |
protected | property | The current raw content. | |
AssertContentTrait:: |
protected | property | The drupalSettings value from the current raw $content. | |
AssertContentTrait:: |
protected | property | The XML structure parsed from the current raw $content. | 1 |
AssertContentTrait:: |
protected | property | The plain-text content of raw $content (text nodes). | |
AssertContentTrait:: |
protected | function | Passes if the raw text IS found escaped on the loaded page, fail otherwise. | |
AssertContentTrait:: |
protected | function | Asserts that a field exists with the given name or ID. | |
AssertContentTrait:: |
protected | function | Asserts that a field exists with the given ID and value. | |
AssertContentTrait:: |
protected | function | Asserts that a field exists with the given name and value. | |
AssertContentTrait:: |
protected | function | Asserts that a field exists in the current page by the given XPath. | |
AssertContentTrait:: |
protected | function | Asserts that a checkbox field in the current page is checked. | |
AssertContentTrait:: |
protected | function | Asserts that a field exists in the current page with a given Xpath result. | |
AssertContentTrait:: |
protected | function | Passes if a link with the specified label is found. | |
AssertContentTrait:: |
protected | function | Passes if a link containing a given href (part) is found. | |
AssertContentTrait:: |
protected | function | Asserts that each HTML ID is used for just a single element. | |
AssertContentTrait:: |
protected | function | Passes if the raw text IS NOT found escaped on the loaded page, fail otherwise. | |
AssertContentTrait:: |
protected | function | Asserts that a field does not exist with the given name or ID. | |
AssertContentTrait:: |
protected | function | Asserts that a field does not exist with the given ID and value. | |
AssertContentTrait:: |
protected | function | Asserts that a field does not exist with the given name and value. | |
AssertContentTrait:: |
protected | function | Asserts that a field does not exist or its value does not match, by XPath. | |
AssertContentTrait:: |
protected | function | Asserts that a checkbox field in the current page is not checked. | |
AssertContentTrait:: |
protected | function | Passes if a link with the specified label is not found. | |
AssertContentTrait:: |
protected | function | Passes if a link containing a given href (part) is not found. | |
AssertContentTrait:: |
protected | function | Passes if a link containing a given href is not found in the main region. | |
AssertContentTrait:: |
protected | function | Asserts that a select option in the current page does not exist. | |
AssertContentTrait:: |
protected | function | Asserts that a select option in the current page is not checked. | |
AssertContentTrait:: |
protected | function | Triggers a pass if the perl regex pattern is not found in raw content. | |
AssertContentTrait:: |
protected | function | Passes if the raw text is NOT found on the loaded page, fail otherwise. | |
AssertContentTrait:: |
protected | function | Passes if the page (with HTML stripped) does not contains the text. | |
AssertContentTrait:: |
protected | function | Pass if the page title is not the given string. | |
AssertContentTrait:: |
protected | function | Passes if the text is found MORE THAN ONCE on the text version of the page. | |
AssertContentTrait:: |
protected | function | Asserts that a select option in the current page exists. | |
AssertContentTrait:: |
protected | function | Asserts that a select option with the visible text exists. | |
AssertContentTrait:: |
protected | function | Asserts that a select option in the current page is checked. | |
AssertContentTrait:: |
protected | function | Asserts that a select option in the current page is checked. | |
AssertContentTrait:: |
protected | function | Asserts that a select option in the current page exists. | |
AssertContentTrait:: |
protected | function | Triggers a pass if the Perl regex pattern is found in the raw content. | |
AssertContentTrait:: |
protected | function | Passes if the raw text IS found on the loaded page, fail otherwise. | |
AssertContentTrait:: |
protected | function | Passes if the page (with HTML stripped) contains the text. | |
AssertContentTrait:: |
protected | function | Helper for assertText and assertNoText. | |
AssertContentTrait:: |
protected | function | Asserts that a Perl regex pattern is found in the plain-text content. | |
AssertContentTrait:: |
protected | function | Asserts themed output. | |
AssertContentTrait:: |
protected | function | Pass if the page title is the given string. | |
AssertContentTrait:: |
protected | function | Passes if the text is found ONLY ONCE on the text version of the page. | |
AssertContentTrait:: |
protected | function | Helper for assertUniqueText and assertNoUniqueText. | |
AssertContentTrait:: |
protected | function | Builds an XPath query. | |
AssertContentTrait:: |
protected | function | Helper: Constructs an XPath for the given set of attributes and value. | |
AssertContentTrait:: |
protected | function | Searches elements using a CSS selector in the raw content. | |
AssertContentTrait:: |
protected | function | Get all option elements, including nested options, in a select. | |
AssertContentTrait:: |
protected | function | Gets the value of drupalSettings for the currently-loaded page. | |
AssertContentTrait:: |
protected | function | Gets the current raw content. | |
AssertContentTrait:: |
protected | function | Get the selected value from a select field. | |
AssertContentTrait:: |
protected | function | Retrieves the plain-text content from the current raw content. | |
AssertContentTrait:: |
protected | function | Get the current URL from the cURL handler. | 1 |
AssertContentTrait:: |
protected | function | Parse content returned from curlExec using DOM and SimpleXML. | |
AssertContentTrait:: |
protected | function | Removes all white-space between HTML tags from the raw content. | |
AssertContentTrait:: |
protected | function | Sets the value of drupalSettings for the currently-loaded page. | |
AssertContentTrait:: |
protected | function | Sets the raw content (e.g. HTML). | |
AssertContentTrait:: |
protected | function | Performs an xpath search on the contents of the internal browser. | |
AssertHelperTrait:: |
protected static | function | Casts MarkupInterface objects into strings. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertTrue() instead. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertEquals() instead. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertSame() instead. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertEquals() instead. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertNotEquals() instead. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertNotSame() instead. | |
AssertLegacyTrait:: |
protected | function | Deprecated Scheduled for removal in Drupal 10.0.0. Use self::assertTrue() instead. | |
AssertLegacyTrait:: |
protected | function | ||
CachedStorageTest:: |
protected | property | The cache backend the cached storage is using. | |
CachedStorageTest:: |
protected | property | The file storage the cached storage is using. | |
CachedStorageTest:: |
public | function | ||
CachedStorageTest:: |
protected | function |
Overrides ConfigStorageTestBase:: |
|
CachedStorageTest:: |
protected | function |
Overrides ConfigStorageTestBase:: |
|
CachedStorageTest:: |
protected | function |
Overrides ConfigStorageTestBase:: |
|
CachedStorageTest:: |
public | function |
Tests an invalid storage. Overrides ConfigStorageTestBase:: |
|
CachedStorageTest:: |
protected | function |
Overrides ConfigStorageTestBase:: |
|
ConfigStorageTestBase:: |
protected | property | ||
ConfigStorageTestBase:: |
protected | property | ||
ConfigStorageTestBase:: |
public | function | Tests that the storage supports collections. | |
ConfigStorageTestBase:: |
public | function | Tests storage CRUD operations. | |
ConfigStorageTestBase:: |
public | function | Tests storage writing and reading data preserving data type. | |
ConfigTestTrait:: |
protected | function | Returns a ConfigImporter object to import test configuration. | |
ConfigTestTrait:: |
protected | function | Copies configuration objects from source storage to target storage. | |
FilteredStorageTest:: |
public | function | Data provider for testDeleteAllFilter. | |
FilteredStorageTest:: |
public | function | Data provider for testDeleteFilter. | |
FilteredStorageTest:: |
protected static | function | Get the filters from a FilteredStorageInterface. | |
FilteredStorageTest:: |
protected | function | Prophesize a StorageFilter. | |
FilteredStorageTest:: |
protected | function | Create a random array. | |
FilteredStorageTest:: |
public | function | Data provider for testReadFilter. | |
FilteredStorageTest:: |
public | function | Data provider for testRenameFilter. | |
FilteredStorageTest:: |
protected | function |
Overrides CachedStorageTest:: |
|
FilteredStorageTest:: |
public | function | Test that creating collections keeps filters set to the correct storages. | |
FilteredStorageTest:: |
public | function | Test setting up filters in FilteredStorage::createCollection(). | |
FilteredStorageTest:: |
public | function | Test the deleteAll method invokes the filterDeleteAll in filters. | |
FilteredStorageTest:: |
public | function | Test the delete method invokes the filterDelete in filters. | |
FilteredStorageTest:: |
public | function | Test collection names from FilteredStorage::getAllCollectionNames(). | |
FilteredStorageTest:: |
public | function | Test that an exception is thrown when invalid arguments are passed. | |
FilteredStorageTest:: |
public | function | Test the read methods invokes the correct filter methods. | |
FilteredStorageTest:: |
public | function | Test that when a filter removes config on a readMultiple it is not set. | |
FilteredStorageTest:: |
public | function | Test the rename method invokes the filterRename in filters. | |
FilteredStorageTest:: |
public | function | Test that the storage is set on the filters. | |
FilteredStorageTest:: |
public | function | Test the write method invokes the filterWrite in filters. | |
FilteredStorageTest:: |
public | function | Data provider for testWriteFilter. | |
KernelTestBase:: |
protected | property | Back up and restore any global variables that may be changed by tests. | |
KernelTestBase:: |
protected | property | Back up and restore static class properties that may be changed by tests. | |
KernelTestBase:: |
protected | property | Contains a few static class properties for performance. | |
KernelTestBase:: |
protected | property | ||
KernelTestBase:: |
protected | property | @todo Move into Config test base class. | 7 |
KernelTestBase:: |
protected static | property | An array of config object names that are excluded from schema checking. | |
KernelTestBase:: |
protected | property | ||
KernelTestBase:: |
protected | property | ||
KernelTestBase:: |
protected static | property | Modules to enable. | 464 |
KernelTestBase:: |
protected | property | Do not forward any global state from the parent process to the processes that run the actual tests. | |
KernelTestBase:: |
protected | property | The app root. | |
KernelTestBase:: |
protected | property | Kernel tests are run in separate processes because they allow autoloading of code from extensions. Running the test in a separate process isolates this behavior from other tests. Subclasses should not override this property. | |
KernelTestBase:: |
protected | property | ||
KernelTestBase:: |
protected | property | Set to TRUE to strict check all configuration saved. | 6 |
KernelTestBase:: |
protected | property | The virtual filesystem root directory. | |
KernelTestBase:: |
protected | function | 1 | |
KernelTestBase:: |
protected | function | Bootstraps a basic test environment. | |
KernelTestBase:: |
private | function | Bootstraps a kernel for a test. | |
KernelTestBase:: |
protected | function | Configuration accessor for tests. Returns non-overridden configuration. | |
KernelTestBase:: |
protected | function | Disables modules for this test. | |
KernelTestBase:: |
protected | function | Enables modules for this test. | |
KernelTestBase:: |
protected | function | Gets the config schema exclusions for this test. | |
KernelTestBase:: |
protected | function | Returns the Database connection info to be used for this test. | 1 |
KernelTestBase:: |
public | function | ||
KernelTestBase:: |
private | function | Returns Extension objects for $modules to enable. | |
KernelTestBase:: |
private static | function | Returns the modules to enable for this test. | |
KernelTestBase:: |
protected | function | Initializes the FileCache component. | |
KernelTestBase:: |
protected | function | Installs default configuration for a given list of modules. | |
KernelTestBase:: |
protected | function | Installs the storage schema for a specific entity type. | |
KernelTestBase:: |
protected | function | Installs database tables from a module schema definition. | |
KernelTestBase:: |
protected | function | Returns whether the current test method is running in a separate process. | |
KernelTestBase:: |
protected | function | ||
KernelTestBase:: |
public | function |
Registers test-specific services. Overrides ServiceProviderInterface:: |
26 |
KernelTestBase:: |
protected | function | Renders a render array. | 1 |
KernelTestBase:: |
protected | function | Sets the install profile and rebuilds the container to update it. | |
KernelTestBase:: |
protected | function | Sets an in-memory Settings variable. | |
KernelTestBase:: |
public static | function | 1 | |
KernelTestBase:: |
protected | function | Sets up the filesystem, so things like the file directory. | 2 |
KernelTestBase:: |
protected | function | Stops test execution. | |
KernelTestBase:: |
protected | function | 6 | |
KernelTestBase:: |
public | function | @after | |
KernelTestBase:: |
protected | function | Dumps the current state of the virtual filesystem to STDOUT. | |
KernelTestBase:: |
public | function | BC: Automatically resolve former KernelTestBase class properties. | |
KernelTestBase:: |
public | function | Prevents serializing any properties. | |
PhpunitCompatibilityTrait:: |
public | function | Returns a mock object for the specified class using the available method. | |
PhpunitCompatibilityTrait:: |
public | function | Compatibility layer for PHPUnit 6 to support PHPUnit 4 code. | |
RandomGeneratorTrait:: |
protected | property | The random generator. | |
RandomGeneratorTrait:: |
protected | function | Gets the random generator for the utility methods. | |
RandomGeneratorTrait:: |
protected | function | Generates a unique random string containing letters and numbers. | 1 |
RandomGeneratorTrait:: |
public | function | Generates a random PHP object. | |
RandomGeneratorTrait:: |
public | function | Generates a pseudo-random string of ASCII characters of codes 32 to 126. | |
RandomGeneratorTrait:: |
public | function | Callback for random string validation. | |
StorageCopyTrait:: |
protected static | function | Copy the configuration from one storage to another and remove stale items. | |
TestRequirementsTrait:: |
private | function | Checks missing module requirements. | |
TestRequirementsTrait:: |
protected | function | Check module requirements for the Drupal use case. | 1 |
TestRequirementsTrait:: |
protected static | function | Returns the Drupal root directory. |