You are here

Home » API reference » Zircon Profile 8.0 » ViewExecutableTest.php

class ViewExecutableTest in Zircon Profile 8.0

Same name in this branch
  1. 8.0 core/modules/views/src/Tests/ViewExecutableTest.php \Drupal\views\Tests\ViewExecutableTest
  2. 8.0 core/modules/views/tests/src/Unit/ViewExecutableTest.php \Drupal\Tests\views\Unit\ViewExecutableTest
Same name and namespace in other branches
  1. 8 core/modules/views/src/Tests/ViewExecutableTest.php \Drupal\views\Tests\ViewExecutableTest

Tests the ViewExecutable class.

@group views

Hierarchy

Expanded class hierarchy of ViewExecutableTest

See also

\Drupal\views\ViewExecutable

File

core/modules/views/src/Tests/ViewExecutableTest.php, line 34
Contains \Drupal\views\Tests\ViewExecutableTest.

Namespace

Drupal\views\Tests
View source 
class ViewExecutableTest extends ViewKernelTestBase {
  use CommentTestTrait;
  public static $modules = [
    'system',
    'node',
    'comment',
    'user',
    'filter',
    'field',
    'text',
  ];

  /**
   * Views used by this test.
   *
   * @var array
   */
  public static $testViews = array(
    'test_destroy',
    'test_executable_displays',
  );

  /**
   * Properties that should be stored in the configuration.
   *
   * @var array
   */
  protected $configProperties = array(
    'disabled',
    'name',
    'description',
    'tag',
    'base_table',
    'label',
    'core',
    'display',
  );

  /**
   * Properties that should be stored in the executable.
   *
   * @var array
   */
  protected $executableProperties = array(
    'storage',
    'built',
    'executed',
    'args',
    'build_info',
    'result',
    'attachment_before',
    'attachment_after',
    'exposed_data',
    'exposed_raw_input',
    'old_view',
    'parent_views',
  );
  protected function setUpFixtures() {
    $this
      ->installEntitySchema('user');
    $this
      ->installEntitySchema('node');
    $this
      ->installEntitySchema('comment');
    $this
      ->installSchema('comment', array(
      'comment_entity_statistics',
    ));
    $this
      ->installConfig(array(
      'system',
      'field',
      'node',
      'comment',
    ));
    entity_create('node_type', array(
      'type' => 'page',
      'name' => 'Page',
    ))
      ->save();
    $this
      ->addDefaultCommentField('node', 'page');
    parent::setUpFixtures();
    $this
      ->installConfig(array(
      'filter',
    ));
  }

  /**
   * Tests the views.executable container service.
   */
  public function testFactoryService() {
    $factory = $this->container
      ->get('views.executable');
    $this
      ->assertTrue($factory instanceof ViewExecutableFactory, 'A ViewExecutableFactory instance was returned from the container.');
    $view = entity_load('view', 'test_executable_displays');
    $this
      ->assertTrue($factory
      ->get($view) instanceof ViewExecutable, 'A ViewExecutable instance was returned from the factory.');
  }

  /**
   * Tests the initDisplay() and initHandlers() methods.
   */
  public function testInitMethods() {
    $view = Views::getView('test_destroy');
    $view
      ->initDisplay();
    $this
      ->assertTrue($view->display_handler instanceof DefaultDisplay, 'Make sure a reference to the current display handler is set.');
    $this
      ->assertTrue($view->displayHandlers
      ->get('default') instanceof DefaultDisplay, 'Make sure a display handler is created for each display.');
    $view
      ->destroy();
    $view
      ->initHandlers();

    // Check for all handler types.
    $handler_types = array_keys(ViewExecutable::getHandlerTypes());
    foreach ($handler_types as $type) {

      // The views_test integration doesn't have relationships.
      if ($type == 'relationship') {
        continue;
      }
      $this
        ->assertTrue(count($view->{$type}), format_string('Make sure a %type instance got instantiated.', array(
        '%type' => $type,
      )));
    }

    // initHandlers() should create display handlers automatically as well.
    $this
      ->assertTrue($view->display_handler instanceof DefaultDisplay, 'Make sure a reference to the current display handler is set.');
    $this
      ->assertTrue($view->displayHandlers
      ->get('default') instanceof DefaultDisplay, 'Make sure a display handler is created for each display.');
    $view_hash = spl_object_hash($view);
    $display_hash = spl_object_hash($view->display_handler);

    // Test the initStyle() method.
    $view
      ->initStyle();
    $this
      ->assertTrue($view->style_plugin instanceof DefaultStyle, 'Make sure a reference to the style plugin is set.');

    // Test the plugin has been inited and view have references to the view and
    // display handler.
    $this
      ->assertEqual(spl_object_hash($view->style_plugin->view), $view_hash);
    $this
      ->assertEqual(spl_object_hash($view->style_plugin->displayHandler), $display_hash);

    // Test the initQuery method().
    $view
      ->initQuery();
    $this
      ->assertTrue($view->query instanceof Sql, 'Make sure a reference to the query is set');
    $this
      ->assertEqual(spl_object_hash($view->query->view), $view_hash);
    $this
      ->assertEqual(spl_object_hash($view->query->displayHandler), $display_hash);
    $view
      ->destroy();

    // Test the plugin  get methods.
    $display_plugin = $view
      ->getDisplay();
    $this
      ->assertTrue($display_plugin instanceof DefaultDisplay, 'An instance of DefaultDisplay was returned.');
    $this
      ->assertTrue($view->display_handler instanceof DefaultDisplay, 'The display_handler property has been set.');
    $this
      ->assertIdentical($display_plugin, $view
      ->getDisplay(), 'The same display plugin instance was returned.');
    $style_plugin = $view
      ->getStyle();
    $this
      ->assertTrue($style_plugin instanceof DefaultStyle, 'An instance of DefaultStyle was returned.');
    $this
      ->assertTrue($view->style_plugin instanceof DefaultStyle, 'The style_plugin property has been set.');
    $this
      ->assertIdentical($style_plugin, $view
      ->getStyle(), 'The same style plugin instance was returned.');
    $pager_plugin = $view
      ->getPager();
    $this
      ->assertTrue($pager_plugin instanceof PagerPluginBase, 'An instance of PagerPluginBase was returned.');
    $this
      ->assertTrue($view->pager instanceof PagerPluginBase, 'The pager property has been set.');
    $this
      ->assertIdentical($pager_plugin, $view
      ->getPager(), 'The same pager plugin instance was returned.');
    $query_plugin = $view
      ->getQuery();
    $this
      ->assertTrue($query_plugin instanceof QueryPluginBase, 'An instance of QueryPluginBase was returned.');
    $this
      ->assertTrue($view->query instanceof QueryPluginBase, 'The query property has been set.');
    $this
      ->assertIdentical($query_plugin, $view
      ->getQuery(), 'The same query plugin instance was returned.');
  }

  /**
   * Tests the generation of the executable object.
   */
  public function testConstructing() {
    Views::getView('test_destroy');
  }

  /**
   * Tests the accessing of values on the object.
   */
  public function testProperties() {
    $view = Views::getView('test_destroy');
    foreach ($this->executableProperties as $property) {
      $this
        ->assertTrue(isset($view->{$property}));
    }

    // Per default exposed input should fall back to an empty array.
    $this
      ->assertEqual($view
      ->getExposedInput(), []);
  }

  /**
   * Tests the display related methods and properties.
   */
  public function testDisplays() {
    $view = Views::getView('test_executable_displays');

    // Tests Drupal\views\ViewExecutable::initDisplay().
    $view
      ->initDisplay();
    $this
      ->assertTrue($view->displayHandlers instanceof DisplayPluginCollection, 'The displayHandlers property has the right class.');

    // Tests the classes of the instances.
    $this
      ->assertTrue($view->displayHandlers
      ->get('default') instanceof DefaultDisplay);
    $this
      ->assertTrue($view->displayHandlers
      ->get('page_1') instanceof Page);
    $this
      ->assertTrue($view->displayHandlers
      ->get('page_2') instanceof Page);

    // After initializing the default display is the current used display.
    $this
      ->assertEqual($view->current_display, 'default');
    $this
      ->assertEqual(spl_object_hash($view->display_handler), spl_object_hash($view->displayHandlers
      ->get('default')));

    // All handlers should have a reference to the default display.
    $this
      ->assertEqual(spl_object_hash($view->displayHandlers
      ->get('page_1')->default_display), spl_object_hash($view->displayHandlers
      ->get('default')));
    $this
      ->assertEqual(spl_object_hash($view->displayHandlers
      ->get('page_2')->default_display), spl_object_hash($view->displayHandlers
      ->get('default')));

    // Tests Drupal\views\ViewExecutable::setDisplay().
    $view
      ->setDisplay();
    $this
      ->assertEqual($view->current_display, 'default', 'If setDisplay is called with no parameter the default display should be used.');
    $this
      ->assertEqual(spl_object_hash($view->display_handler), spl_object_hash($view->displayHandlers
      ->get('default')));

    // Set two different valid displays.
    $view
      ->setDisplay('page_1');
    $this
      ->assertEqual($view->current_display, 'page_1', 'If setDisplay is called with a valid display id the appropriate display should be used.');
    $this
      ->assertEqual(spl_object_hash($view->display_handler), spl_object_hash($view->displayHandlers
      ->get('page_1')));
    $view
      ->setDisplay('page_2');
    $this
      ->assertEqual($view->current_display, 'page_2', 'If setDisplay is called with a valid display id the appropriate display should be used.');
    $this
      ->assertEqual(spl_object_hash($view->display_handler), spl_object_hash($view->displayHandlers
      ->get('page_2')));

    // Destroy the view, so we can start again and test an invalid display.
    $view
      ->destroy();
    $count_before = count($this->assertions);
    $view
      ->setDisplay('invalid');
    $count_after = count($this->assertions);
    $this
      ->assertTrue($count_after - $count_before, 'Error is triggered while calling the wrong display.');
    $this
      ->assertEqual($view->current_display, 'default', 'If setDisplay is called with an invalid display id the default display should be used.');
    $this
      ->assertEqual(spl_object_hash($view->display_handler), spl_object_hash($view->displayHandlers
      ->get('default')));

    // Test the style and row plugins are replaced correctly when setting the
    // display.
    $view
      ->setDisplay('page_1');
    $view
      ->initStyle();
    $this
      ->assertTrue($view->style_plugin instanceof DefaultStyle);
    $this
      ->assertTrue($view->rowPlugin instanceof Fields);
    $view
      ->setDisplay('page_2');
    $view
      ->initStyle();
    $this
      ->assertTrue($view->style_plugin instanceof Grid);

    // @todo Change this rowPlugin type too.
    $this
      ->assertTrue($view->rowPlugin instanceof Fields);

    // Test the newDisplay() method.
    $view = $this->container
      ->get('entity.manager')
      ->getStorage('view')
      ->create(array(
      'id' => 'test_executable_displays',
    ));
    $executable = $view
      ->getExecutable();
    $executable
      ->newDisplay('page');
    $executable
      ->newDisplay('page');
    $executable
      ->newDisplay('display_test');
    $this
      ->assertTrue($executable->displayHandlers
      ->get('default') instanceof DefaultDisplay);
    $this
      ->assertFalse(isset($executable->displayHandlers
      ->get('default')->default_display));
    $this
      ->assertTrue($executable->displayHandlers
      ->get('page_1') instanceof Page);
    $this
      ->assertTrue($executable->displayHandlers
      ->get('page_1')->default_display instanceof DefaultDisplay);
    $this
      ->assertTrue($executable->displayHandlers
      ->get('page_2') instanceof Page);
    $this
      ->assertTrue($executable->displayHandlers
      ->get('page_2')->default_display instanceof DefaultDisplay);
    $this
      ->assertTrue($executable->displayHandlers
      ->get('display_test_1') instanceof DisplayTest);
    $this
      ->assertTrue($executable->displayHandlers
      ->get('display_test_1')->default_display instanceof DefaultDisplay);
  }

  /**
   * Tests the setting/getting of properties.
   */
  public function testPropertyMethods() {
    $view = Views::getView('test_executable_displays');

    // Test the setAjaxEnabled() method.
    $this
      ->assertFalse($view
      ->ajaxEnabled());
    $view
      ->setAjaxEnabled(TRUE);
    $this
      ->assertTrue($view
      ->ajaxEnabled());
    $view
      ->setDisplay();

    // There should be no pager set initially.
    $this
      ->assertNull($view
      ->usePager());

    // Add a pager, initialize, and test.
    $view->displayHandlers
      ->get('default')
      ->overrideOption('pager', array(
      'type' => 'full',
      'options' => array(
        'items_per_page' => 10,
      ),
    ));
    $view
      ->initPager();
    $this
      ->assertTrue($view
      ->usePager());

    // Test setting and getting the offset.
    $rand = rand();
    $view
      ->setOffset($rand);
    $this
      ->assertEqual($view
      ->getOffset(), $rand);

    // Test the getBaseTable() method.
    $expected = array(
      'views_test_data' => TRUE,
      '#global' => TRUE,
    );
    $this
      ->assertIdentical($view
      ->getBaseTables(), $expected);

    // Test response methods.
    $this
      ->assertTrue($view
      ->getResponse() instanceof Response, 'New response object returned.');
    $new_response = new Response();
    $view
      ->setResponse($new_response);
    $this
      ->assertIdentical(spl_object_hash($view
      ->getResponse()), spl_object_hash($new_response), 'New response object correctly set.');

    // Test the getPath() method.
    $path = $this
      ->randomMachineName();
    $view->displayHandlers
      ->get('page_1')
      ->overrideOption('path', $path);
    $view
      ->setDisplay('page_1');
    $this
      ->assertEqual($view
      ->getPath(), $path);

    // Test the override_path property override.
    $override_path = $this
      ->randomMachineName();
    $view->override_path = $override_path;
    $this
      ->assertEqual($view
      ->getPath(), $override_path);

    // Test the title methods.
    $title = $this
      ->randomString();
    $view
      ->setTitle($title);
    $this
      ->assertEqual($view
      ->getTitle(), Xss::filterAdmin($title));
  }

  /**
   * Tests the deconstructor to be sure that necessary objects are removed.
   */
  public function testDestroy() {
    $view = Views::getView('test_destroy');
    $view
      ->preview();
    $view
      ->destroy();
    $this
      ->assertViewDestroy($view);
  }

  /**
   * Asserts that expected view properties have been unset by destroy().
   *
   * @param \Drupal\views\ViewExecutable $view
   */
  protected function assertViewDestroy($view) {
    $reflection = new \ReflectionClass($view);
    $defaults = $reflection
      ->getDefaultProperties();

    // The storage and user should remain.
    unset($defaults['storage'], $defaults['user'], $defaults['request'], $defaults['routeProvider']);
    foreach ($defaults as $property => $default) {
      $this
        ->assertIdentical($this
        ->getProtectedProperty($view, $property), $default);
    }
  }

  /**
   * Returns a protected property from a class instance.
   *
   * @param object $instance
   *   The class instance to return the property from.
   * @param string $property
   *   The name of the property to return.
   *
   * @return mixed
   *   The instance property value.
   */
  protected function getProtectedProperty($instance, $property) {
    $reflection = new \ReflectionProperty($instance, $property);
    $reflection
      ->setAccessible(TRUE);
    return $reflection
      ->getValue($instance);
  }

  /**
   * Tests ViewExecutable::getHandlerTypes().
   */
  public function testGetHandlerTypes() {
    $types = ViewExecutable::getHandlerTypes();
    foreach (array(
      'field',
      'filter',
      'argument',
      'sort',
      'header',
      'footer',
      'empty',
    ) as $type) {
      $this
        ->assertTrue(isset($types[$type]));

      // @todo The key on the display should be footers, headers and empties
      //   or something similar instead of the singular, but so long check for
      //   this special case.
      if (isset($types[$type]['type']) && $types[$type]['type'] == 'area') {
        $this
          ->assertEqual($types[$type]['plural'], $type);
      }
      else {
        $this
          ->assertEqual($types[$type]['plural'], $type . 's');
      }
    }
  }

  /**
   * Tests ViewExecutable::getHandlers().
   */
  public function testGetHandlers() {
    $view = Views::getView('test_executable_displays');
    $view
      ->setDisplay('page_1');
    $view
      ->getHandlers('field', 'page_2');

    // getHandlers() shouldn't change the active display.
    $this
      ->assertEqual('page_1', $view->current_display, "The display shouldn't change after getHandlers()");
  }

  /**
   * Tests the validation of display handlers.
   */
  public function testValidate() {
    $view = Views::getView('test_executable_displays');
    $view
      ->setDisplay('page_1');
    $validate = $view
      ->validate();

    // Validating a view shouldn't change the active display.
    $this
      ->assertEqual('page_1', $view->current_display, "The display should be constant while validating");
    $count = 0;
    foreach ($view->displayHandlers as $id => $display) {
      $match = function ($value) use ($display) {
        return strpos($value, $display->display['display_title']) !== false;
      };
      $this
        ->assertTrue(array_filter($validate[$id], $match), format_string('Error message found for @id display', array(
        '@id' => $id,
      )));
      $count++;
    }
    $this
      ->assertEqual(count($view->displayHandlers), $count, 'Error messages from all handlers merged.');

    // Test that a deleted display is not included.
    $display =& $view->storage
      ->getDisplay('default');
    $display['deleted'] = TRUE;
    $validate_deleted = $view
      ->validate();
    $this
      ->assertNotIdentical($validate, $validate_deleted, 'Master display has not been validated.');
  }

  /**
   * Tests that nested loops of the display handlers won't break validation.
   */
  public function testValidateNestedLoops() {
    $view = View::create([
      'id' => 'test_validate_nested_loops',
    ]);
    $executable = $view
      ->getExecutable();
    $executable
      ->newDisplay('display_test');
    $executable
      ->newDisplay('display_test');
    $errors = $executable
      ->validate();
    $total_error_count = array_reduce($errors, function ($carry, $item) {
      $carry += count($item);
      return $carry;
    });

    // Assert that there were 9 total errors across 3 displays.
    $this
      ->assertIdentical(9, $total_error_count);
    $this
      ->assertIdentical(3, count($errors));
  }

  /**
   * Tests serialization of the ViewExecutable object.
   */
  public function testSerialization() {
    $view = Views::getView('test_executable_displays');
    $view
      ->setDisplay('page_1');
    $view
      ->setArguments([
      'test',
    ]);
    $view
      ->setCurrentPage(2);
    $serialized = serialize($view);

    // Test the view storage object is not present in the actual serialized
    // string.
    $this
      ->assertIdentical(strpos($serialized, '"Drupal\\views\\Entity\\View"'), FALSE, 'The Drupal\\views\\Entity\\View class was not found in the serialized string.');

    /** @var \Drupal\views\ViewExecutable $unserialized */
    $unserialized = unserialize($serialized);
    $this
      ->assertTrue($unserialized instanceof ViewExecutable);
    $this
      ->assertIdentical($view->storage
      ->id(), $unserialized->storage
      ->id(), 'The expected storage entity was loaded on the unserialized view.');
    $this
      ->assertIdentical($unserialized->current_display, 'page_1', 'The expected display was set on the unserialized view.');
    $this
      ->assertIdentical($unserialized->args, [
      'test',
    ], 'The expected argument was set on the unserialized view.');
    $this
      ->assertIdentical($unserialized
      ->getCurrentPage(), 2, 'The expected current page was set on the unserialized view.');
  }

}

Members

Namesort descending Modifiers Type Description Overrides
AssertContentTrait::$content protected property The current raw content.
AssertContentTrait::$drupalSettings protected property The drupalSettings value from the current raw $content.
AssertContentTrait::$elements protected property The XML structure parsed from the current raw $content. 2
AssertContentTrait::$plainTextContent protected property The plain-text content of raw $content (text nodes).
AssertContentTrait::assertEscaped protected function Passes if the raw text IS found escaped on the loaded page, fail otherwise.
AssertContentTrait::assertField protected function Asserts that a field exists with the given name or ID.
AssertContentTrait::assertFieldById protected function Asserts that a field exists with the given ID and value.
AssertContentTrait::assertFieldByName protected function Asserts that a field exists with the given name and value.
AssertContentTrait::assertFieldByXPath protected function Asserts that a field exists in the current page by the given XPath.
AssertContentTrait::assertFieldChecked protected function Asserts that a checkbox field in the current page is checked.
AssertContentTrait::assertFieldsByValue protected function Asserts that a field exists in the current page with a given Xpath result.
AssertContentTrait::assertLink protected function Passes if a link with the specified label is found.
AssertContentTrait::assertLinkByHref protected function Passes if a link containing a given href (part) is found.
AssertContentTrait::assertNoDuplicateIds protected function Asserts that each HTML ID is used for just a single element.
AssertContentTrait::assertNoEscaped protected function Passes if the raw text IS NOT found escaped on the loaded page, fail otherwise.
AssertContentTrait::assertNoField protected function Asserts that a field does not exist with the given name or ID.
AssertContentTrait::assertNoFieldById protected function Asserts that a field does not exist with the given ID and value.
AssertContentTrait::assertNoFieldByName protected function Asserts that a field does not exist with the given name and value.
AssertContentTrait::assertNoFieldByXPath protected function Asserts that a field does not exist or its value does not match, by XPath.
AssertContentTrait::assertNoFieldChecked protected function Asserts that a checkbox field in the current page is not checked.
AssertContentTrait::assertNoLink protected function Passes if a link with the specified label is not found.
AssertContentTrait::assertNoLinkByHref protected function Passes if a link containing a given href (part) is not found.
AssertContentTrait::assertNoLinkByHrefInMainRegion protected function Passes if a link containing a given href is not found in the main region.
AssertContentTrait::assertNoOption protected function Asserts that a select option in the current page does not exist.
AssertContentTrait::assertNoOptionSelected protected function Asserts that a select option in the current page is not checked.
AssertContentTrait::assertNoPattern protected function Triggers a pass if the perl regex pattern is not found in raw content.
AssertContentTrait::assertNoRaw protected function Passes if the raw text is NOT found on the loaded page, fail otherwise.
AssertContentTrait::assertNoText protected function Passes if the page (with HTML stripped) does not contains the text.
AssertContentTrait::assertNoTitle protected function Pass if the page title is not the given string.
AssertContentTrait::assertNoUniqueText protected function Passes if the text is found MORE THAN ONCE on the text version of the page.
AssertContentTrait::assertOption protected function Asserts that a select option in the current page exists.
AssertContentTrait::assertOptionSelected protected function Asserts that a select option in the current page is checked.
AssertContentTrait::assertOptionSelectedWithDrupalSelector protected function Asserts that a select option in the current page is checked.
AssertContentTrait::assertOptionWithDrupalSelector protected function Asserts that a select option in the current page exists.
AssertContentTrait::assertPattern protected function Triggers a pass if the Perl regex pattern is found in the raw content.
AssertContentTrait::assertRaw protected function Passes if the raw text IS found on the loaded page, fail otherwise.
AssertContentTrait::assertText protected function Passes if the page (with HTML stripped) contains the text.
AssertContentTrait::assertTextHelper protected function Helper for assertText and assertNoText.
AssertContentTrait::assertTextPattern protected function Asserts that a Perl regex pattern is found in the plain-text content.
AssertContentTrait::assertThemeOutput protected function Asserts themed output.
AssertContentTrait::assertTitle protected function Pass if the page title is the given string.
AssertContentTrait::assertUniqueText protected function Passes if the text is found ONLY ONCE on the text version of the page.
AssertContentTrait::assertUniqueTextHelper protected function Helper for assertUniqueText and assertNoUniqueText.
AssertContentTrait::buildXPathQuery protected function Builds an XPath query.
AssertContentTrait::constructFieldXpath protected function Helper: Constructs an XPath for the given set of attributes and value.
AssertContentTrait::cssSelect protected function Searches elements using a CSS selector in the raw content.
AssertContentTrait::getAllOptions protected function Get all option elements, including nested options, in a select.
AssertContentTrait::getDrupalSettings protected function Gets the value of drupalSettings for the currently-loaded page.
AssertContentTrait::getRawContent protected function Gets the current raw content.
AssertContentTrait::getSelectedItem protected function Get the selected value from a select field.
AssertContentTrait::getTextContent protected function Retrieves the plain-text content from the current raw content.
AssertContentTrait::getUrl protected function Get the current URL from the cURL handler. 1
AssertContentTrait::parse protected function Parse content returned from curlExec using DOM and SimpleXML.
AssertContentTrait::removeWhiteSpace protected function Removes all white-space between HTML tags from the raw content.
AssertContentTrait::setDrupalSettings protected function Sets the value of drupalSettings for the currently-loaded page.
AssertContentTrait::setRawContent protected function Sets the raw content (e.g. HTML).
AssertContentTrait::xpath protected function Performs an xpath search on the contents of the internal browser.
AssertHelperTrait::castSafeStrings protected function Casts MarkupInterface objects into strings.
CommentTestTrait::addDefaultCommentField public function Adds the default comment field to an entity.
KernelTestBase::$configDirectories protected property The configuration directories for this test run.
KernelTestBase::$keyValueFactory protected property A KeyValueMemoryFactory instance to use when building the container.
KernelTestBase::$moduleFiles private property
KernelTestBase::$streamWrappers protected property Array of registered stream wrappers.
KernelTestBase::$themeFiles private property
KernelTestBase::beforePrepareEnvironment protected function Act on global state information before the environment is altered for a test. Overrides TestBase::beforePrepareEnvironment
KernelTestBase::containerBuild public function Sets up the base service container for this test. 12
KernelTestBase::defaultLanguageData protected function Provides the data for setting the default language on the container. 1
KernelTestBase::disableModules protected function Disables modules for this test.
KernelTestBase::enableModules protected function Enables modules for this test.
KernelTestBase::installConfig protected function Installs default configuration for a given list of modules.
KernelTestBase::installEntitySchema protected function Installs the storage schema for a specific entity type.
KernelTestBase::installSchema protected function Installs a specific table from a module schema definition.
KernelTestBase::prepareConfigDirectories protected function Create and set new configuration directories. 1
KernelTestBase::registerStreamWrapper protected function Registers a stream wrapper for this test.
KernelTestBase::render protected function Renders a render array.
KernelTestBase::tearDown protected function Performs cleanup tasks after each individual test method has been run. Overrides TestBase::tearDown
KernelTestBase::__construct function Constructor for Test. Overrides TestBase::__construct
RandomGeneratorTrait::$randomGenerator protected property The random generator.
RandomGeneratorTrait::getRandomGenerator protected function Gets the random generator for the utility methods.
RandomGeneratorTrait::randomMachineName protected function Generates a unique random string containing letters and numbers.
RandomGeneratorTrait::randomObject public function Generates a random PHP object.
RandomGeneratorTrait::randomString public function Generates a pseudo-random string of ASCII characters of codes 32 to 126.
RandomGeneratorTrait::randomStringValidate public function Callback for random string validation.
SessionTestTrait::$sessionName protected property The name of the session cookie.
SessionTestTrait::generateSessionName protected function Generates a session cookie name.
SessionTestTrait::getSessionName protected function Returns the session name in use on the child site.
TestBase::$assertions protected property Assertions thrown in that test case.
TestBase::$configImporter protected property The config importer that can used in a test. 5
TestBase::$configSchemaCheckerExclusions protected static property An array of config object names that are excluded from schema checking.
TestBase::$container protected property The dependency injection container used in the test.
TestBase::$databasePrefix protected property The database prefix of this test run.
TestBase::$dieOnFail public property Whether to die in case any test assertion fails.
TestBase::$httpAuthCredentials protected property HTTP authentication credentials (<username>:<password>).
TestBase::$httpAuthMethod protected property HTTP authentication method (specified as a CURLAUTH_* constant).
TestBase::$kernel protected property The DrupalKernel instance used in the test. 1
TestBase::$originalConf protected property The original configuration (variables), if available.
TestBase::$originalConfig protected property The original configuration (variables).
TestBase::$originalConfigDirectories protected property The original configuration directories.
TestBase::$originalContainer protected property The original container.
TestBase::$originalFileDirectory protected property The original file directory, before it was changed for testing purposes.
TestBase::$originalLanguage protected property The original language.
TestBase::$originalPrefix protected property The original database prefix when running inside Simpletest.
TestBase::$originalProfile protected property The original installation profile.
TestBase::$originalSessionName protected property The name of the session cookie of the test-runner.
TestBase::$originalSettings protected property The settings array.
TestBase::$originalShutdownCallbacks protected property The original array of shutdown function callbacks. 1
TestBase::$originalSite protected property The site directory of the original parent site.
TestBase::$originalUser protected property The original user, before testing began. 1
TestBase::$privateFilesDirectory protected property The private file directory for the test environment.
TestBase::$publicFilesDirectory protected property The public file directory for the test environment.
TestBase::$results public property Current results of this test case.
TestBase::$siteDirectory protected property The site directory of this test run.
TestBase::$skipClasses protected property This class is skipped when looking for the source of an assertion.
TestBase::$strictConfigSchema protected property Set to TRUE to strict check all configuration saved. 4
TestBase::$tempFilesDirectory protected property The temporary file directory for the test environment.
TestBase::$testId protected property The test run ID.
TestBase::$timeLimit protected property Time limit for the test.
TestBase::$translationFilesDirectory protected property The translation file directory for the test environment.
TestBase::$verbose public property TRUE if verbose debugging is enabled.
TestBase::$verboseClassName protected property Safe class name for use in verbose output filenames.
TestBase::$verboseDirectory protected property Directory where verbose output files are put.
TestBase::$verboseDirectoryUrl protected property URL to the verbose output file directory.
TestBase::$verboseId protected property Incrementing identifier for verbose output filenames.
TestBase::assert protected function Internal helper: stores the assert.
TestBase::assertEqual protected function Check to see if two values are equal.
TestBase::assertErrorLogged protected function Asserts that a specific error has been logged to the PHP error log.
TestBase::assertFalse protected function Check to see if a value is false.
TestBase::assertIdentical protected function Check to see if two values are identical.
TestBase::assertIdenticalObject protected function Checks to see if two objects are identical.
TestBase::assertNoErrorsLogged protected function Asserts that no errors have been logged to the PHP error.log thus far.
TestBase::assertNotEqual protected function Check to see if two values are not equal.
TestBase::assertNotIdentical protected function Check to see if two values are not identical.
TestBase::assertNotNull protected function Check to see if a value is not NULL.
TestBase::assertNull protected function Check to see if a value is NULL.
TestBase::assertTrue protected function Check to see if a value is not false.
TestBase::changeDatabasePrefix private function Changes the database connection to the prefixed one.
TestBase::checkRequirements protected function Checks the matching requirements for Test. 2
TestBase::config protected function Configuration accessor for tests. Returns non-overridden configuration.
TestBase::configImporter public function Returns a ConfigImporter object to import test importing of configuration. 5
TestBase::copyConfig public function Copies configuration objects from source storage to target storage.
TestBase::deleteAssert public static function Delete an assertion record by message ID.
TestBase::error protected function Fire an error assertion. 3
TestBase::errorHandler public function Handle errors during test runs.
TestBase::exceptionHandler protected function Handle exceptions.
TestBase::fail protected function Fire an assertion that is always negative.
TestBase::filePreDeleteCallback public static function Ensures test files are deletable within file_unmanaged_delete_recursive().
TestBase::generatePermutations public static function Converts a list of possible parameters into a stack of permutations.
TestBase::getAssertionCall protected function Cycles through backtrace until the first non-assertion method is found.
TestBase::getConfigSchemaExclusions protected function Gets the config schema exclusions for this test.
TestBase::getDatabaseConnection public static function Returns the database connection to the site running Simpletest.
TestBase::getDatabasePrefix public function Gets the database prefix.
TestBase::getTempFilesDirectory public function Gets the temporary files directory.
TestBase::insertAssert public static function Store an assertion from outside the testing context.
TestBase::pass protected function Fire an assertion that is always positive.
TestBase::prepareDatabasePrefix private function Generates a database prefix for running tests.
TestBase::prepareEnvironment private function Prepares the current environment for running the test.
TestBase::restoreEnvironment private function Cleans up the test environment and restores the original environment.
TestBase::run public function Run all tests in this class. 1
TestBase::settingsSet protected function Changes in memory settings.
TestBase::storeAssertion protected function Helper method to store an assertion record in the configured database.
TestBase::verbose protected function Logs a verbose message in a text file.
ViewExecutableTest::$configProperties protected property Properties that should be stored in the configuration.
ViewExecutableTest::$executableProperties protected property Properties that should be stored in the executable.
ViewExecutableTest::$modules public static property Modules to enable. Overrides ViewKernelTestBase::$modules
ViewExecutableTest::$testViews public static property Views used by this test.
ViewExecutableTest::assertViewDestroy protected function Asserts that expected view properties have been unset by destroy().
ViewExecutableTest::getProtectedProperty protected function Returns a protected property from a class instance.
ViewExecutableTest::setUpFixtures protected function Sets up the configuration and schema of views and views_test_data modules. Overrides ViewKernelTestBase::setUpFixtures
ViewExecutableTest::testConstructing public function Tests the generation of the executable object.
ViewExecutableTest::testDestroy public function Tests the deconstructor to be sure that necessary objects are removed.
ViewExecutableTest::testDisplays public function Tests the display related methods and properties.
ViewExecutableTest::testFactoryService public function Tests the views.executable container service.
ViewExecutableTest::testGetHandlers public function Tests ViewExecutable::getHandlers().
ViewExecutableTest::testGetHandlerTypes public function Tests ViewExecutable::getHandlerTypes().
ViewExecutableTest::testInitMethods public function Tests the initDisplay() and initHandlers() methods.
ViewExecutableTest::testProperties public function Tests the accessing of values on the object.
ViewExecutableTest::testPropertyMethods public function Tests the setting/getting of properties.
ViewExecutableTest::testSerialization public function Tests serialization of the ViewExecutable object.
ViewExecutableTest::testValidate public function Tests the validation of display handlers.
ViewExecutableTest::testValidateNestedLoops public function Tests that nested loops of the display handlers won't break validation.
ViewKernelTestBase::dataSet protected function Returns a very simple test dataset. 8
ViewKernelTestBase::executeView protected function Executes a view with debugging.
ViewKernelTestBase::orderResultSet protected function Orders a nested array containing a result set based on a given column.
ViewKernelTestBase::schemaDefinition protected function Returns the schema definition. 6
ViewKernelTestBase::setUp protected function Overrides KernelTestBase::setUp 37
ViewKernelTestBase::viewsData protected function Returns the views data definition. 19
ViewResultAssertionTrait::assertIdenticalResultset protected function Verifies that a result set returned by a View matches expected values.
ViewResultAssertionTrait::assertIdenticalResultsetHelper protected function Performs View result assertions.
ViewResultAssertionTrait::assertNotIdenticalResultset protected function Verifies that a result set returned by a View differs from certain values.