Tests the fetching of views data.
Expanded class hierarchy of ViewsDataTest
hook_views_data
class ViewsDataTest extends ViewUnitTestBase {
/**
* Stores the views data cache service used by this test.
*
* @var \Drupal\views\ViewsData
*/
protected $viewsData;
/**
* Stores a count for hook_views_data being invoked.
*
* @var int
*/
protected $count = 0;
/**
* The memory backend to use for the test.
*
* @var \Drupal\Core\Cache\MemoryCounterBackend
*/
protected $memoryCounterBackend;
public static function getInfo() {
return array(
'name' => 'Views data',
'description' => 'Tests the fetching of views data.',
'group' => 'Views',
);
}
protected function setUp() {
parent::setUp();
$this->memoryCounterBackend = new MemoryCounterBackend('views_info');
$this->state = $this->container
->get('state');
$this
->initViewsData();
}
/**
* Tests the views.views_data service.
*
* @see \Drupal\views\ViewsData
*/
public function testViewsFetchData() {
$table_name = 'views_test_data';
$random_table_name = $this
->randomName();
// Invoke expected data directly from hook_views_data implementations.
$expected_data = $this->container
->get('module_handler')
->invokeAll('views_data');
// Verify that views_test_data_views_data() has only been called once after
// calling clear().
$this
->startCount();
$this->viewsData
->get();
// Test views data has been invoked.
$this
->assertCountIncrement();
// Clear the storage/cache.
$this->viewsData
->clear();
// Get the data again.
$this->viewsData
->get();
$this->viewsData
->get($table_name);
$this->viewsData
->get($random_table_name);
// Verify that view_test_data_views_data() has run once.
$this
->assertCountIncrement();
// Get the data again.
$this->viewsData
->get();
$this->viewsData
->get($table_name);
$this->viewsData
->get($random_table_name);
// Verify that view_test_data_views_data() has not run again.
$this
->assertCountIncrement(FALSE);
// Clear the views data, and test all table data.
$this->viewsData
->clear();
$this
->startCount();
$data = $this->viewsData
->get();
$this
->assertEqual($data, $expected_data, 'Make sure fetching all views data by works as expected.');
// Views data should be invoked once.
$this
->assertCountIncrement();
// Calling get() again, the count for this table should stay the same.
$data = $this->viewsData
->get();
$this
->assertEqual($data, $expected_data, 'Make sure fetching all cached views data works as expected.');
$this
->assertCountIncrement(FALSE);
// Clear the views data, and test data for a specific table.
$this->viewsData
->clear();
$this
->startCount();
$data = $this->viewsData
->get($table_name);
$this
->assertEqual($data, $expected_data[$table_name], 'Make sure fetching views data by table works as expected.');
// Views data should be invoked once.
$this
->assertCountIncrement();
// Calling get() again, the count for this table should stay the same.
$data = $this->viewsData
->get($table_name);
$this
->assertEqual($data, $expected_data[$table_name], 'Make sure fetching cached views data by table works as expected.');
$this
->assertCountIncrement(FALSE);
// Test that this data is present if all views data is returned.
$data = $this->viewsData
->get();
$this
->assertTrue(isset($data[$table_name]), 'Make sure the views_test_data info appears in the total views data.');
$this
->assertEqual($data[$table_name], $expected_data[$table_name], 'Make sure the views_test_data has the expected values.');
// Clear the views data, and test data for an invalid table.
$this->viewsData
->clear();
$this
->startCount();
// All views data should be requested on the first try.
$data = $this->viewsData
->get($random_table_name);
$this
->assertEqual($data, array(), 'Make sure fetching views data for an invalid table returns an empty array.');
$this
->assertCountIncrement();
// Test no data is rebuilt when requesting an invalid table again.
$data = $this->viewsData
->get($random_table_name);
$this
->assertEqual($data, array(), 'Make sure fetching views data for an invalid table returns an empty array.');
$this
->assertCountIncrement(FALSE);
}
/**
* Ensures that cache entries are only set and get when necessary.
*/
public function testCacheRequests() {
// Request the same table 5 times. The caches are empty at this point, so
// what will happen is that it will first check for a cache entry for the
// given table, get a cache miss, then try the cache entry for all tables,
// which does not exist yet either. As a result, it rebuilds the information
// and writes a cache entry for all tables and the requested table.
$table_name = 'views_test_data';
for ($i = 0; $i < 5; $i++) {
$this->viewsData
->get($table_name);
}
// Assert cache set and get calls.
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:views_test_data:en'), 1, 'Requested the cache for the table-specific cache entry.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:en'), 1, 'Requested the cache for all tables.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:views_test_data:en'), 1, 'Wrote the cache for the requested once.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:en'), 1, 'Wrote the cache for the all tables once.');
// Re-initialize the views data cache to simulate a new request and repeat.
// We have a warm cache now, so this will only request the tables-specific
// cache entry and return that.
$this
->initViewsData();
for ($i = 0; $i < 5; $i++) {
$this->viewsData
->get($table_name);
}
// Assert cache set and get calls.
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:views_test_data:en'), 1, 'Requested the cache for the table-specific cache entry.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:en'), 0, 'Did not request to load the cache entry for all tables.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:views_test_data:en'), 0, 'Did not write the cache for the requested table.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:en'), 0, 'Did not write the cache for all tables.');
// Re-initialize the views data cache to simulate a new request and request
// a different table. This will fail to get a table specific cache entry,
// load the cache entry for all tables and save a cache entry for this table
// but not all.
$this
->initViewsData();
$another_table_name = 'views';
for ($i = 0; $i < 5; $i++) {
$this->viewsData
->get($another_table_name);
}
// Assert cache set and get calls.
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:views:en'), 1, 'Requested the cache for the table-specific cache entry.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:en'), 1, 'Requested the cache for all tables.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:views:en'), 1, 'Wrote the cache for the requested once.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:en'), 0, 'Did not write the cache for all tables.');
// Re-initialize the views data cache to simulate a new request and request
// a non-existing table. This will result in the same cache requests as we
// explicitly write an empty cache entry for non-existing tables to avoid
// unecessary requests in those situations. We do have to load the cache
// entry for all tables to check if the table does exist or not.
$this
->initViewsData();
$non_existing_table = $this
->randomName();
for ($i = 0; $i < 5; $i++) {
$this->viewsData
->get($non_existing_table);
}
// Assert cache set and get calls.
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', "views_data:{$non_existing_table}:en"), 1, 'Requested the cache for the table-specific cache entry.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:en'), 1, 'Requested the cache for all tables.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', "views_data:{$non_existing_table}:en"), 1, 'Wrote the cache for the requested once.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:en'), 0, 'Did not write the cache for all tables.');
// Re-initialize the views data cache to simulate a new request and request
// the same non-existing table. This will load the table-specific cache
// entry and return the stored empty array for that.
$this
->initViewsData();
for ($i = 0; $i < 5; $i++) {
$this->viewsData
->get($non_existing_table);
}
// Assert cache set and get calls.
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', "views_data:{$non_existing_table}:en"), 1, 'Requested the cache for the table-specific cache entry.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:en'), 0, 'Did not request to load the cache entry for all tables.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', "views_data:{$non_existing_table}:en"), 0, 'Did not write the cache for the requested table.');
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:en'), 0, 'Did not write the cache for all tables.');
// Re-initialize the views data cache and repeat with no specified table.
// This should only load the cache entry for all tables.
$this
->initViewsData();
for ($i = 0; $i < 5; $i++) {
$this->viewsData
->get();
}
// This only requested the full information. No other cache requests should
// have been made.
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:views_test_data:en'), 0);
$this
->assertEqual($this->memoryCounterBackend
->getCounter('get', 'views_data:en'), 1);
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:views_test_data:en'), 0);
$this
->assertEqual($this->memoryCounterBackend
->getCounter('set', 'views_data:en'), 0);
}
/**
* Initializes a new ViewsData instance and resets the cache backend.
*/
protected function initViewsData() {
$this->memoryCounterBackend
->resetCounter();
$this->viewsData = new ViewsData($this->memoryCounterBackend, $this->container
->get('config.factory'), $this->container
->get('module_handler'));
}
/**
* Starts a count for hook_views_data being invoked.
*/
protected function startCount() {
$count = $this->state
->get('views_test_data_views_data_count');
$this->count = isset($count) ? $count : 0;
}
/**
* Asserts that the count for hook_views_data either equal or has increased.
*
* @param bool $equal
* Whether to assert that the count should be equal. Defaults to FALSE.
*/
protected function assertCountIncrement($increment = TRUE) {
if ($increment) {
// If an incremented count is expected, increment this now.
$this->count++;
$message = 'hook_views_data has been invoked.';
}
else {
$message = 'hook_views_data has not been invoked';
}
$this
->assertEqual($this->count, $this->state
->get('views_test_data_views_data_count'), $message);
}
/**
* Overrides Drupal\views\Tests\ViewTestBase::viewsData().
*/
protected function viewsData() {
$data = parent::viewsData();
// Tweak the views data to have a base for testing views_fetch_fields().
unset($data['views_test_data']['id']['field']);
unset($data['views_test_data']['name']['argument']);
unset($data['views_test_data']['age']['filter']);
unset($data['views_test_data']['job']['sort']);
$data['views_test_data']['created']['area']['id'] = 'text';
$data['views_test_data']['age']['area']['id'] = 'text';
$data['views_test_data']['age']['area']['sub_type'] = 'header';
$data['views_test_data']['job']['area']['id'] = 'text';
$data['views_test_data']['job']['area']['sub_type'] = array(
'header',
'footer',
);
return $data;
}
/**
* Tests the views_fetch_fields function().
*/
public function testViewsFetchFields() {
$this
->enableModules(array(
'views_ui',
));
$this->container
->get('module_handler')
->loadInclude('views_ui', 'inc', 'admin');
$expected = array(
'field' => array(
'name',
'age',
'job',
'created',
),
'argument' => array(
'id',
'age',
'job',
'created',
),
'filter' => array(
'id',
'name',
'job',
'created',
),
'sort' => array(
'id',
'name',
'age',
'created',
),
'area' => array(
'created',
'job',
'age',
),
'header' => array(
'created',
'job',
'age',
),
'footer' => array(
'created',
'job',
),
);
$handler_types = array(
'field',
'argument',
'filter',
'sort',
'area',
);
foreach ($handler_types as $handler_type) {
$fields = views_fetch_fields('views_test_data', $handler_type);
$expected_keys = array_walk($expected[$handler_type], function (&$item) {
$item = "views_test_data.{$item}";
});
$this
->assertEqual($expected_keys, array_keys($fields), format_string('Handlers of type @handler_type are listed as expected.', array(
'@handler_type' => $handler_type,
)));
}
// Check for subtype filtering, so header and footer.
foreach (array(
'header',
'footer',
) as $sub_type) {
$fields = views_fetch_fields('views_test_data', 'area', FALSE, $sub_type);
$expected_keys = array_walk($expected[$sub_type], function (&$item) {
$item = "views_test_data.{$item}";
});
$this
->assertEqual($expected_keys, array_keys($fields), format_string('Sub_type @sub_type is filtered as expected.', array(
'@sub_type' => $sub_type,
)));
}
}
/**
* Tests the fetchBaseTables() method.
*/
public function testFetchBaseTables() {
// Enabled node module so there is more than 1 base table to test.
$this
->enableModules(array(
'node',
));
$data = $this->viewsData
->get();
$base_tables = $this->viewsData
->fetchBaseTables();
// Test the number of tables returned and their order.
$this
->assertEqual(count($base_tables), 3, 'The correct amount of base tables were returned.');
$this
->assertIdentical(array_keys($base_tables), array(
'node',
'node_field_revision',
'views_test_data',
), 'The tables are sorted as expected.');
// Test the values returned for each base table.
$defaults = array(
'title' => '',
'help' => '',
'weight' => 0,
);
foreach ($base_tables as $base_table => $info) {
// Merge in default values as in fetchBaseTables().
$expected = $data[$base_table]['table']['base'] += $defaults;
foreach ($defaults as $key => $default) {
$this
->assertEqual($info[$key], $expected[$key]);
}
}
}
}
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
DrupalUnitTestBase:: |
protected | property | A KeyValueMemoryFactory instance to use when building the container. | |
DrupalUnitTestBase:: |
private | property | ||
DrupalUnitTestBase:: |
private | property | ||
DrupalUnitTestBase:: |
private | property | ||
DrupalUnitTestBase:: |
public | function | Sets up the base service container for this test. | 1 |
DrupalUnitTestBase:: |
protected | function | Disables modules for this test. | |
DrupalUnitTestBase:: |
protected | function | Enables modules for this test. | |
DrupalUnitTestBase:: |
protected | function | Installs default configuration for a given list of modules. | |
DrupalUnitTestBase:: |
protected | function | Installs a specific table from a module schema definition. | |
DrupalUnitTestBase:: |
protected | function |
Deletes created files, database tables, and reverts all environment changes. Overrides TestBase:: |
2 |
DrupalUnitTestBase:: |
function |
Overrides \Drupal\simpletest\UnitTestBase::__construct(). Overrides UnitTestBase:: |
||
TestBase:: |
protected | property | Assertions thrown in that test case. | |
TestBase:: |
protected | property | The config importer that can used in a test. | 1 |
TestBase:: |
protected | property | The dependency injection container used in the test. | 1 |
TestBase:: |
protected | property | The database prefix of this test run. | |
TestBase:: |
public | property | Whether to die in case any test assertion fails. | |
TestBase:: |
protected | property | The original file directory, before it was changed for testing purposes. | |
TestBase:: |
protected | property | The original database prefix when running inside Simpletest. | |
TestBase:: |
protected | property | The settings array. | |
TestBase:: |
protected | property | The public file directory for the test environment. | |
TestBase:: |
public | property | Current results of this test case. | |
TestBase:: |
protected | property | Flag to indicate whether the test has been set up. | |
TestBase:: |
protected | property | ||
TestBase:: |
protected | property | ||
TestBase:: |
protected | property | This class is skipped when looking for the source of an assertion. | |
TestBase:: |
protected | property | The test run ID. | |
TestBase:: |
protected | property | Time limit for the test. | |
TestBase:: |
protected | property | TRUE if verbose debugging is enabled. | |
TestBase:: |
protected | property | Safe class name for use in verbose output filenames. | |
TestBase:: |
protected | property | Directory where verbose output files are put. | |
TestBase:: |
protected | property | URL to the verbose output file directory. | |
TestBase:: |
protected | property | Incrementing identifier for verbose output filenames. | |
TestBase:: |
protected | function | Internal helper: stores the assert. | |
TestBase:: |
protected | function | Check to see if two values are equal. | |
TestBase:: |
protected | function | Check to see if a value is false (an empty string, 0, NULL, or FALSE). | |
TestBase:: |
protected | function | Check to see if two values are identical. | |
TestBase:: |
protected | function | Checks to see if two objects are identical. | |
TestBase:: |
protected | function | Check to see if two values are not equal. | |
TestBase:: |
protected | function | Check to see if two values are not identical. | |
TestBase:: |
protected | function | Check to see if a value is not NULL. | |
TestBase:: |
protected | function | Check to see if a value is NULL. | |
TestBase:: |
protected | function | Check to see if a value is not false (not an empty string, 0, NULL, or FALSE). | |
TestBase:: |
protected | function | Changes the database connection to the prefixed one. | |
TestBase:: |
protected | function | Checks the matching requirements for Test. | 4 |
TestBase:: |
public | function | Returns a ConfigImporter object to import test importing of configuration. | 1 |
TestBase:: |
public | function | Copies configuration objects from source storage to target storage. | |
TestBase:: |
public static | function | Delete an assertion record by message ID. | |
TestBase:: |
protected | function | Fire an error assertion. | 1 |
TestBase:: |
public | function | Handle errors during test runs. | |
TestBase:: |
protected | function | Handle exceptions. | |
TestBase:: |
protected | function | Fire an assertion that is always negative. | |
TestBase:: |
public static | function | Ensures test files are deletable within file_unmanaged_delete_recursive(). | |
TestBase:: |
public static | function | Converts a list of possible parameters into a stack of permutations. | |
TestBase:: |
protected | function | Cycles through backtrace until the first non-assertion method is found. | |
TestBase:: |
public static | function | Returns the database connection to the site running Simpletest. | |
TestBase:: |
public static | function | Store an assertion from outside the testing context. | |
TestBase:: |
protected | function | Fire an assertion that is always positive. | |
TestBase:: |
protected | function | Create and set new configuration directories. | 1 |
TestBase:: |
protected | function | Generates a database prefix for running tests. | |
TestBase:: |
protected | function | Prepares the current environment for running the test. | |
TestBase:: |
public static | function | Generates a random string containing letters and numbers. | |
TestBase:: |
public static | function | Generates a random PHP object. | |
TestBase:: |
public static | function | Generates a random string of ASCII characters of codes 32 to 126. | |
TestBase:: |
protected | function | Rebuild drupal_container(). | 1 |
TestBase:: |
public | function | Run all tests in this class. | |
TestBase:: |
protected | function | Changes in memory settings. | |
TestBase:: |
protected | function | Logs verbose message in a text file. | |
UnitTestBase:: |
protected | property | ||
ViewsDataTest:: |
protected | property | Stores a count for hook_views_data being invoked. | |
ViewsDataTest:: |
protected | property | The memory backend to use for the test. | |
ViewsDataTest:: |
protected | property | Stores the views data cache service used by this test. | |
ViewsDataTest:: |
protected | function | Asserts that the count for hook_views_data either equal or has increased. | |
ViewsDataTest:: |
public static | function | ||
ViewsDataTest:: |
protected | function | Initializes a new ViewsData instance and resets the cache backend. | |
ViewsDataTest:: |
protected | function |
Sets up Drupal unit test environment. Overrides ViewUnitTestBase:: |
|
ViewsDataTest:: |
protected | function | Starts a count for hook_views_data being invoked. | |
ViewsDataTest:: |
public | function | Ensures that cache entries are only set and get when necessary. | |
ViewsDataTest:: |
public | function | Tests the fetchBaseTables() method. | |
ViewsDataTest:: |
public | function | Tests the views.views_data service. | |
ViewsDataTest:: |
public | function | Tests the views_fetch_fields function(). | |
ViewsDataTest:: |
protected | function |
Overrides Drupal\views\Tests\ViewTestBase::viewsData(). Overrides ViewUnitTestBase:: |
|
ViewUnitTestBase:: |
public static | property |
Modules to enable. Overrides DrupalUnitTestBase:: |
21 |
ViewUnitTestBase:: |
protected | function | Verifies that a result set returned by a View matches expected values. | |
ViewUnitTestBase:: |
protected | function | Performs View result assertions. | |
ViewUnitTestBase:: |
protected | function | Verifies that a result set returned by a View differs from certain values. | |
ViewUnitTestBase:: |
protected | function | Returns a very simple test dataset. | 7 |
ViewUnitTestBase:: |
protected | function | Executes a view with debugging. | |
ViewUnitTestBase:: |
protected | function | Orders a nested array containing a result set based on a given column. | |
ViewUnitTestBase:: |
protected | function | Returns the schema definition. | 4 |
ViewUnitTestBase:: |
protected | function | Sets up the configuration and schema of views and views_test_data modules. | 2 |