File

modules/simpletest/tests/bootstrap.test
View source
<?php

class BootstrapIPAddressTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'IP address and HTTP_HOST test',
      'description' => 'Get the IP address from the current visitor from the server variables, check hostname validation.',
      'group' => 'Bootstrap',
    );
  }
  function setUp() {
    $this->oldserver = $_SERVER;
    $this->remote_ip = '127.0.0.1';
    $this->proxy_ip = '127.0.0.2';
    $this->proxy2_ip = '127.0.0.3';
    $this->forwarded_ip = '127.0.0.4';
    $this->cluster_ip = '127.0.0.5';
    $this->untrusted_ip = '0.0.0.0';
    drupal_static_reset('ip_address');
    $_SERVER['REMOTE_ADDR'] = $this->remote_ip;
    unset($_SERVER['HTTP_X_FORWARDED_FOR']);
    unset($_SERVER['HTTP_X_CLUSTER_CLIENT_IP']);
    parent::setUp();
  }
  function tearDown() {
    $_SERVER = $this->oldserver;
    drupal_static_reset('ip_address');
    parent::tearDown();
  }

  /**
   * test IP Address and hostname
   */
  function testIPAddressHost() {

    // Test the normal IP address.
    $this
      ->assertTrue(ip_address() == $this->remote_ip, 'Got remote IP address.');

    // Proxy forwarding on but no proxy addresses defined.
    variable_set('reverse_proxy', 1);
    $this
      ->assertTrue(ip_address() == $this->remote_ip, 'Proxy forwarding without trusted proxies got remote IP address.');

    // Proxy forwarding on and proxy address not trusted.
    variable_set('reverse_proxy_addresses', array(
      $this->proxy_ip,
      $this->proxy2_ip,
    ));
    drupal_static_reset('ip_address');
    $_SERVER['REMOTE_ADDR'] = $this->untrusted_ip;
    $this
      ->assertTrue(ip_address() == $this->untrusted_ip, 'Proxy forwarding with untrusted proxy got remote IP address.');

    // Proxy forwarding on and proxy address trusted.
    $_SERVER['REMOTE_ADDR'] = $this->proxy_ip;
    $_SERVER['HTTP_X_FORWARDED_FOR'] = $this->forwarded_ip;
    drupal_static_reset('ip_address');
    $this
      ->assertTrue(ip_address() == $this->forwarded_ip, 'Proxy forwarding with trusted proxy got forwarded IP address.');

    // Proxy forwarding on and proxy address trusted and visiting from proxy.
    $_SERVER['REMOTE_ADDR'] = $this->proxy_ip;
    $_SERVER['HTTP_X_FORWARDED_FOR'] = $this->proxy_ip;
    drupal_static_reset('ip_address');
    $this
      ->assertTrue(ip_address() == $this->proxy_ip, 'Visiting from trusted proxy got proxy IP address.');

    // Multi-tier architecture with comma separated values in header.
    $_SERVER['REMOTE_ADDR'] = $this->proxy_ip;
    $_SERVER['HTTP_X_FORWARDED_FOR'] = implode(', ', array(
      $this->untrusted_ip,
      $this->forwarded_ip,
      $this->proxy2_ip,
    ));
    drupal_static_reset('ip_address');
    $this
      ->assertTrue(ip_address() == $this->forwarded_ip, 'Proxy forwarding with trusted 2-tier proxy got forwarded IP address.');

    // Custom client-IP header.
    variable_set('reverse_proxy_header', 'HTTP_X_CLUSTER_CLIENT_IP');
    $_SERVER['HTTP_X_CLUSTER_CLIENT_IP'] = $this->cluster_ip;
    drupal_static_reset('ip_address');
    $this
      ->assertTrue(ip_address() == $this->cluster_ip, 'Cluster environment got cluster client IP.');

    // Verifies that drupal_valid_http_host() prevents invalid characters.
    $this
      ->assertFalse(drupal_valid_http_host('security/.drupal.org:80'), 'HTTP_HOST with / is invalid');
    $this
      ->assertFalse(drupal_valid_http_host('security\\.drupal.org:80'), 'HTTP_HOST with \\ is invalid');
    $this
      ->assertFalse(drupal_valid_http_host('security<.drupal.org:80'), 'HTTP_HOST with &lt; is invalid');
    $this
      ->assertFalse(drupal_valid_http_host('security..drupal.org:80'), 'HTTP_HOST with .. is invalid');

    // Verifies that host names are shorter than 1000 characters.
    $this
      ->assertFalse(drupal_valid_http_host(str_repeat('x', 1001)), 'HTTP_HOST with more than 1000 characters is invalid.');
    $this
      ->assertFalse(drupal_valid_http_host(str_repeat('.', 101)), 'HTTP_HOST with more than 100 subdomains is invalid.');
    $this
      ->assertFalse(drupal_valid_http_host(str_repeat(':', 101)), 'HTTP_HOST with more than 100 portseparators is invalid.');

    // IPv6 loopback address
    $this
      ->assertTrue(drupal_valid_http_host('[::1]:80'), 'HTTP_HOST containing IPv6 loopback is valid');
  }

}
class BootstrapPageCacheTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Page cache test',
      'description' => 'Enable the page cache and test it with various HTTP requests.',
      'group' => 'Bootstrap',
    );
  }
  function setUp() {
    parent::setUp('system_test');
  }

  /**
   * Test support for requests containing If-Modified-Since and If-None-Match headers.
   */
  function testConditionalRequests() {
    variable_set('cache', 1);

    // Fill the cache.
    $this
      ->drupalGet('');
    $this
      ->drupalHead('');
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'HIT', 'Page was cached.');
    $etag = $this
      ->drupalGetHeader('ETag');
    $last_modified = $this
      ->drupalGetHeader('Last-Modified');
    $this
      ->drupalGet('', array(), array(
      'If-Modified-Since: ' . $last_modified,
      'If-None-Match: ' . $etag,
    ));
    $this
      ->assertResponse(304, 'Conditional request returned 304 Not Modified.');
    $this
      ->drupalGet('', array(), array(
      'If-Modified-Since: ' . gmdate(DATE_RFC822, strtotime($last_modified)),
      'If-None-Match: ' . $etag,
    ));
    $this
      ->assertResponse(304, 'Conditional request with obsolete If-Modified-Since date returned 304 Not Modified.');
    $this
      ->drupalGet('', array(), array(
      'If-Modified-Since: ' . gmdate(DATE_RFC850, strtotime($last_modified)),
      'If-None-Match: ' . $etag,
    ));
    $this
      ->assertResponse(304, 'Conditional request with obsolete If-Modified-Since date returned 304 Not Modified.');
    $this
      ->drupalGet('', array(), array(
      'If-Modified-Since: ' . $last_modified,
    ));
    $this
      ->assertResponse(200, 'Conditional request without If-None-Match returned 200 OK.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'HIT', 'Page was cached.');
    $this
      ->drupalGet('', array(), array(
      'If-Modified-Since: ' . gmdate(DATE_RFC7231, strtotime($last_modified) + 1),
      'If-None-Match: ' . $etag,
    ));
    $this
      ->assertResponse(200, 'Conditional request with new a If-Modified-Since date newer than Last-Modified returned 200 OK.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'HIT', 'Page was cached.');
    $user = $this
      ->drupalCreateUser();
    $this
      ->drupalLogin($user);
    $this
      ->drupalGet('', array(), array(
      'If-Modified-Since: ' . $last_modified,
      'If-None-Match: ' . $etag,
    ));
    $this
      ->assertResponse(200, 'Conditional request returned 200 OK for authenticated user.');
    $this
      ->assertFalse($this
      ->drupalGetHeader('X-Drupal-Cache'), 'Absence of Page was not cached.');
    $this
      ->assertFalse($this
      ->drupalGetHeader('ETag'), 'ETag HTTP headers are not present for logged in users.');
    $this
      ->assertFalse($this
      ->drupalGetHeader('Last-Modified'), 'Last-Modified HTTP headers are not present for logged in users.');
  }

  /**
   * Test cache headers.
   */
  function testPageCache() {
    variable_set('cache', 1);

    // Fill the cache.
    $this
      ->drupalGet('system-test/set-header', array(
      'query' => array(
        'name' => 'Foo',
        'value' => 'bar',
      ),
    ));
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'MISS', 'Page was not cached.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Vary'), 'Cookie,Accept-Encoding', 'Vary header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Cache-Control'), 'public, max-age=0', 'Cache-Control header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Expires'), 'Sun, 19 Nov 1978 05:00:00 GMT', 'Expires header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Foo'), 'bar', 'Custom header was sent.');

    // Check cache.
    $this
      ->drupalGet('system-test/set-header', array(
      'query' => array(
        'name' => 'Foo',
        'value' => 'bar',
      ),
    ));
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'HIT', 'Page was cached.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Vary'), 'Cookie,Accept-Encoding', 'Vary: Cookie header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Cache-Control'), 'public, max-age=0', 'Cache-Control header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Expires'), 'Sun, 19 Nov 1978 05:00:00 GMT', 'Expires header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Foo'), 'bar', 'Custom header was sent.');

    // Check replacing default headers.
    $this
      ->drupalGet('system-test/set-header', array(
      'query' => array(
        'name' => 'Expires',
        'value' => 'Fri, 19 Nov 2008 05:00:00 GMT',
      ),
    ));
    $this
      ->assertEqual($this
      ->drupalGetHeader('Expires'), 'Fri, 19 Nov 2008 05:00:00 GMT', 'Default header was replaced.');
    $this
      ->drupalGet('system-test/set-header', array(
      'query' => array(
        'name' => 'Vary',
        'value' => 'User-Agent',
      ),
    ));
    $this
      ->assertEqual($this
      ->drupalGetHeader('Vary'), 'User-Agent,Accept-Encoding', 'Default header was replaced.');

    // Check that authenticated users bypass the cache.
    $user = $this
      ->drupalCreateUser();
    $this
      ->drupalLogin($user);
    $this
      ->drupalGet('system-test/set-header', array(
      'query' => array(
        'name' => 'Foo',
        'value' => 'bar',
      ),
    ));
    $this
      ->assertFalse($this
      ->drupalGetHeader('X-Drupal-Cache'), 'Caching was bypassed.');
    $this
      ->assertTrue(strpos($this
      ->drupalGetHeader('Vary'), 'Cookie') === FALSE, 'Vary: Cookie header was not sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Cache-Control'), 'no-cache, must-revalidate', 'Cache-Control header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Expires'), 'Sun, 19 Nov 1978 05:00:00 GMT', 'Expires header was sent.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Foo'), 'bar', 'Custom header was sent.');
  }

  /**
   * Test page compression.
   *
   * The test should pass even if zlib.output_compression is enabled in php.ini,
   * .htaccess or similar, or if compression is done outside PHP, e.g. by the
   * mod_deflate Apache module.
   */
  function testPageCompression() {
    variable_set('cache', 1);

    // Fill the cache and verify that output is compressed.
    $this
      ->drupalGet('', array(), array(
      'Accept-Encoding: gzip,deflate',
    ));
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'MISS', 'Page was not cached.');
    $this
      ->drupalSetContent(gzinflate(substr($this
      ->drupalGetContent(), 10, -8)));
    $this
      ->assertRaw('</html>', 'Page was gzip compressed.');

    // Verify that cached output is compressed.
    $this
      ->drupalGet('', array(), array(
      'Accept-Encoding: gzip,deflate',
    ));
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'HIT', 'Page was cached.');
    $this
      ->assertEqual($this
      ->drupalGetHeader('Content-Encoding'), 'gzip', 'A Content-Encoding header was sent.');
    $this
      ->drupalSetContent(gzinflate(substr($this
      ->drupalGetContent(), 10, -8)));
    $this
      ->assertRaw('</html>', 'Page was gzip compressed.');

    // Verify that a client without compression support gets an uncompressed page.
    $this
      ->drupalGet('');
    $this
      ->assertEqual($this
      ->drupalGetHeader('X-Drupal-Cache'), 'HIT', 'Page was cached.');
    $this
      ->assertFalse($this
      ->drupalGetHeader('Content-Encoding'), 'A Content-Encoding header was not sent.');
    $this
      ->assertTitle(t('Welcome to @site-name | @site-name', array(
      '@site-name' => variable_get('site_name', 'Drupal'),
    )), 'Site title matches.');
    $this
      ->assertRaw('</html>', 'Page was not compressed.');

    // Disable compression mode.
    variable_set('page_compression', FALSE);

    // Verify if cached page is still available for a client with compression support.
    $this
      ->drupalGet('', array(), array(
      'Accept-Encoding: gzip,deflate',
    ));
    $this
      ->drupalSetContent(gzinflate(substr($this
      ->drupalGetContent(), 10, -8)));
    $this
      ->assertRaw('</html>', 'Page was delivered after compression mode is changed (compression support enabled).');

    // Verify if cached page is still available for a client without compression support.
    $this
      ->drupalGet('');
    $this
      ->assertRaw('</html>', 'Page was delivered after compression mode is changed (compression support disabled).');
  }

}
class BootstrapVariableTestCase extends DrupalWebTestCase {
  function setUp() {
    parent::setUp('system_test');
  }
  public static function getInfo() {
    return array(
      'name' => 'Variable test',
      'description' => 'Make sure the variable system functions correctly.',
      'group' => 'Bootstrap',
    );
  }

  /**
   * testVariable
   */
  function testVariable() {

    // Setting and retrieving values.
    $variable = $this
      ->randomName();
    variable_set('simpletest_bootstrap_variable_test', $variable);
    $this
      ->assertIdentical($variable, variable_get('simpletest_bootstrap_variable_test'), 'Setting and retrieving values');

    // Make sure the variable persists across multiple requests.
    $this
      ->drupalGet('system-test/variable-get');
    $this
      ->assertText($variable, 'Variable persists across multiple requests');

    // Deleting variables.
    $default_value = $this
      ->randomName();
    variable_del('simpletest_bootstrap_variable_test');
    $variable = variable_get('simpletest_bootstrap_variable_test', $default_value);
    $this
      ->assertIdentical($variable, $default_value, 'Deleting variables');
  }

  /**
   * Makes sure that the default variable parameter is passed through okay.
   */
  function testVariableDefaults() {

    // Tests passing nothing through to the default.
    $this
      ->assertIdentical(NULL, variable_get('simpletest_bootstrap_variable_test'), 'Variables are correctly defaulting to NULL.');

    // Tests passing 5 to the default parameter.
    $this
      ->assertIdentical(5, variable_get('simpletest_bootstrap_variable_test', 5), 'The default variable parameter is passed through correctly.');
  }

}

/**
 * Tests the auto-loading behavior of the code registry.
 */
class BootstrapAutoloadTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Code registry',
      'description' => 'Test that the code registry functions correctly.',
      'group' => 'Bootstrap',
    );
  }
  function setUp() {
    parent::setUp('drupal_autoload_test');
  }

  /**
   * Tests that autoloader name matching is not case sensitive.
   */
  function testAutoloadCase() {

    // Test interface autoloader.
    $this
      ->assertTrue(drupal_autoload_interface('drupalautoloadtestinterface'), 'drupal_autoload_interface() recognizes <em>DrupalAutoloadTestInterface</em> in lower case.');

    // Test class autoloader.
    $this
      ->assertTrue(drupal_autoload_class('drupalautoloadtestclass'), 'drupal_autoload_class() recognizes <em>DrupalAutoloadTestClass</em> in lower case.');

    // Test trait autoloader.
    if (version_compare(PHP_VERSION, '5.4') >= 0) {
      $this
        ->assertTrue(drupal_autoload_trait('drupalautoloadtesttrait'), 'drupal_autoload_trait() recognizes <em>DrupalAutoloadTestTrait</em> in lower case.');
    }
  }

}

/**
 * Test hook_boot() and hook_exit().
 */
class HookBootExitTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Boot and exit hook invocation',
      'description' => 'Test that hook_boot() and hook_exit() are called correctly.',
      'group' => 'Bootstrap',
    );
  }
  function setUp() {
    parent::setUp('system_test', 'dblog');
  }

  /**
   * Test calling of hook_boot() and hook_exit().
   */
  function testHookBootExit() {

    // Test with cache disabled. Boot and exit should always fire.
    variable_set('cache', 0);
    $this
      ->drupalGet('');
    $calls = 1;
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_boot',
    ))
      ->fetchField(), $calls, t('hook_boot called with disabled cache.'));
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_exit',
    ))
      ->fetchField(), $calls, t('hook_exit called with disabled cache.'));

    // Test with normal cache. Boot and exit should be called.
    variable_set('cache', 1);
    $this
      ->drupalGet('');
    $calls++;
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_boot',
    ))
      ->fetchField(), $calls, t('hook_boot called with normal cache.'));
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_exit',
    ))
      ->fetchField(), $calls, t('hook_exit called with normal cache.'));

    // Boot and exit should not fire since the page is cached.
    variable_set('page_cache_invoke_hooks', FALSE);
    $this
      ->assertTrue(cache_get(url('', array(
      'absolute' => TRUE,
    )), 'cache_page'), t('Page has been cached.'));
    $this
      ->drupalGet('');
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_boot',
    ))
      ->fetchField(), $calls, t('hook_boot not called with aggressive cache and a cached page.'));
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_exit',
    ))
      ->fetchField(), $calls, t('hook_exit not called with aggressive cache and a cached page.'));

    // Test with page cache cleared, boot and exit should be called.
    $this
      ->assertTrue(db_delete('cache_page')
      ->execute(), t('Page cache cleared.'));
    $this
      ->drupalGet('');
    $calls++;
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_boot',
    ))
      ->fetchField(), $calls, t('hook_boot called with aggressive cache and no cached page.'));
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND message = :message', array(
      ':type' => 'system_test',
      ':message' => 'hook_exit',
    ))
      ->fetchField(), $calls, t('hook_exit called with aggressive cache and no cached page.'));
  }

}

/**
 * Test drupal_get_filename()'s availability.
 */
class BootstrapGetFilenameTestCase extends DrupalUnitTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Get filename test (without the system table)',
      'description' => 'Test that drupal_get_filename() works correctly when the database is not available.',
      'group' => 'Bootstrap',
    );
  }

  /**
   * The last file-related error message triggered by the filename test.
   *
   * Used by BootstrapGetFilenameTestCase::testDrupalGetFilename().
   */
  protected $getFilenameTestTriggeredError;

  /**
   * Test that drupal_get_filename() works correctly when the file is not found in the database.
   */
  function testDrupalGetFilename() {

    // Reset the static cache so we can test the "db is not active" code of
    // drupal_get_filename().
    drupal_static_reset('drupal_get_filename');

    // Retrieving the location of a module.
    $this
      ->assertIdentical(drupal_get_filename('module', 'php'), 'modules/php/php.module', t('Retrieve module location.'));

    // Retrieving the location of a theme.
    $this
      ->assertIdentical(drupal_get_filename('theme', 'stark'), 'themes/stark/stark.info', t('Retrieve theme location.'));

    // Retrieving the location of a theme engine.
    $this
      ->assertIdentical(drupal_get_filename('theme_engine', 'phptemplate'), 'themes/engines/phptemplate/phptemplate.engine', t('Retrieve theme engine location.'));

    // Retrieving the location of a profile. Profiles are a special case with
    // a fixed location and naming.
    $this
      ->assertIdentical(drupal_get_filename('profile', 'standard'), 'profiles/standard/standard.profile', t('Retrieve install profile location.'));

    // When a file is not found in the database cache, drupal_get_filename()
    // searches several locations on the filesystem, including the DRUPAL_ROOT
    // directory. We use the '.script' extension below because this is a
    // non-existent filetype that will definitely not exist in the database.
    // Since there is already a scripts directory, drupal_get_filename() will
    // automatically check there for 'script' files, just as it does for (e.g.)
    // 'module' files in modules.
    $this
      ->assertIdentical(drupal_get_filename('script', 'test'), 'scripts/test.script', t('Retrieve test script location.'));

    // When searching for a module that does not exist, drupal_get_filename()
    // should return NULL and trigger an appropriate error message.
    $this->getFilenameTestTriggeredError = NULL;
    set_error_handler(array(
      $this,
      'fileNotFoundErrorHandler',
    ));
    $non_existing_module = $this
      ->randomName();
    $this
      ->assertNull(drupal_get_filename('module', $non_existing_module), 'Searching for a module that does not exist returns NULL.');
    $this
      ->assertTrue(strpos($this->getFilenameTestTriggeredError, format_string('The following module is missing from the file system: %name', array(
      '%name' => $non_existing_module,
    ))) === 0, 'Searching for an item that does not exist triggers the correct error.');
    restore_error_handler();

    // Check that the result is stored in the file system scan cache.
    $file_scans = _drupal_file_scan_cache();
    $this
      ->assertIdentical($file_scans['module'][$non_existing_module], FALSE, 'Searching for a module that does not exist creates a record in the missing and moved files static variable.');

    // Performing the search again in the same request still should not find
    // the file, but the error message should not be repeated (therefore we do
    // not override the error handler here).
    $this
      ->assertNull(drupal_get_filename('module', $non_existing_module), 'Searching for a module that does not exist returns NULL during the second search.');
  }

  /**
   * Skips handling of "file not found" errors.
   */
  public function fileNotFoundErrorHandler($error_level, $message, $filename, $line, $context) {

    // Skip error handling if this is a "file not found" error.
    if (strpos($message, 'is missing from the file system:') !== FALSE || strpos($message, 'has moved within the file system:') !== FALSE) {
      $this->getFilenameTestTriggeredError = $message;
      return;
    }
    _drupal_error_handler($error_level, $message, $filename, $line, $context);
  }

}

/**
 * Test drupal_get_filename() in the context of a full Drupal installation.
 */
class BootstrapGetFilenameWebTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Get filename test (full installation)',
      'description' => 'Test that drupal_get_filename() works correctly in the context of a full Drupal installation.',
      'group' => 'Bootstrap',
    );
  }
  function setUp() {
    parent::setUp('system_test');
  }

  /**
   * The last file-related error message triggered by the filename test.
   *
   * Used by BootstrapGetFilenameWebTestCase::testDrupalGetFilename().
   */
  protected $getFilenameTestTriggeredError;

  /**
   * Test that drupal_get_filename() works correctly with a full Drupal site.
   */
  function testDrupalGetFilename() {

    // Search for a module that exists in the file system and the {system}
    // table and make sure that it is found.
    $this
      ->assertIdentical(drupal_get_filename('module', 'node'), 'modules/node/node.module', 'Module found at expected location.');

    // Search for a module that does not exist in either the file system or the
    // {system} table. Make sure that an appropriate error is triggered and
    // that the module winds up in the static and persistent cache.
    $this->getFilenameTestTriggeredError = NULL;
    set_error_handler(array(
      $this,
      'fileNotFoundErrorHandler',
    ));
    $non_existing_module = $this
      ->randomName();
    $this
      ->assertNull(drupal_get_filename('module', $non_existing_module), 'Searching for a module that does not exist returns NULL.');
    $this
      ->assertTrue(strpos($this->getFilenameTestTriggeredError, format_string('The following module is missing from the file system: %name', array(
      '%name' => $non_existing_module,
    ))) === 0, 'Searching for a module that does not exist triggers the correct error.');
    restore_error_handler();
    $file_scans = _drupal_file_scan_cache();
    $this
      ->assertIdentical($file_scans['module'][$non_existing_module], FALSE, 'Searching for a module that does not exist creates a record in the missing and moved files static variable.');
    drupal_file_scan_write_cache();
    $cache = cache_get('_drupal_file_scan_cache', 'cache_bootstrap');
    $this
      ->assertIdentical($cache->data['module'][$non_existing_module], FALSE, 'Searching for a module that does not exist creates a record in the missing and moved files persistent cache.');

    // Simulate moving a module to a location that does not match the location
    // in the {system} table and perform similar tests as above.
    db_update('system')
      ->fields(array(
      'filename' => 'modules/simpletest/tests/fake_location/module_test.module',
    ))
      ->condition('name', 'module_test')
      ->condition('type', 'module')
      ->execute();
    $this->getFilenameTestTriggeredError = NULL;
    set_error_handler(array(
      $this,
      'fileNotFoundErrorHandler',
    ));
    $this
      ->assertIdentical(drupal_get_filename('module', 'module_test'), 'modules/simpletest/tests/module_test.module', 'Searching for a module that has moved finds the module at its new location.');
    $this
      ->assertTrue(strpos($this->getFilenameTestTriggeredError, format_string('The following module has moved within the file system: %name', array(
      '%name' => 'module_test',
    ))) === 0, 'Searching for a module that has moved triggers the correct error.');
    restore_error_handler();
    $file_scans = _drupal_file_scan_cache();
    $this
      ->assertIdentical($file_scans['module']['module_test'], 'modules/simpletest/tests/module_test.module', 'Searching for a module that has moved creates a record in the missing and moved files static variable.');
    drupal_file_scan_write_cache();
    $cache = cache_get('_drupal_file_scan_cache', 'cache_bootstrap');
    $this
      ->assertIdentical($cache->data['module']['module_test'], 'modules/simpletest/tests/module_test.module', 'Searching for a module that has moved creates a record in the missing and moved files persistent cache.');

    // Simulate a module that exists in the {system} table but does not exist
    // in the file system and perform similar tests as above.
    $non_existing_module = $this
      ->randomName();
    db_update('system')
      ->fields(array(
      'name' => $non_existing_module,
    ))
      ->condition('name', 'module_test')
      ->condition('type', 'module')
      ->execute();
    $this->getFilenameTestTriggeredError = NULL;
    set_error_handler(array(
      $this,
      'fileNotFoundErrorHandler',
    ));
    $this
      ->assertNull(drupal_get_filename('module', $non_existing_module), 'Searching for a module that exists in the system table but not in the file system returns NULL.');
    $this
      ->assertTrue(strpos($this->getFilenameTestTriggeredError, format_string('The following module is missing from the file system: %name', array(
      '%name' => $non_existing_module,
    ))) === 0, 'Searching for a module that exists in the system table but not in the file system triggers the correct error.');
    restore_error_handler();
    $file_scans = _drupal_file_scan_cache();
    $this
      ->assertIdentical($file_scans['module'][$non_existing_module], FALSE, 'Searching for a module that exists in the system table but not in the file system creates a record in the missing and moved files static variable.');
    drupal_file_scan_write_cache();
    $cache = cache_get('_drupal_file_scan_cache', 'cache_bootstrap');
    $this
      ->assertIdentical($cache->data['module'][$non_existing_module], FALSE, 'Searching for a module that exists in the system table but not in the file system creates a record in the missing and moved files persistent cache.');

    // Simulate a module that exists in the file system but not in the {system}
    // table and perform similar tests as above.
    db_delete('system')
      ->condition('name', 'common_test')
      ->condition('type', 'module')
      ->execute();
    system_list_reset();
    $this->getFilenameTestTriggeredError = NULL;
    set_error_handler(array(
      $this,
      'fileNotFoundErrorHandler',
    ));
    $this
      ->assertIdentical(drupal_get_filename('module', 'common_test'), 'modules/simpletest/tests/common_test.module', 'Searching for a module that does not exist in the system table finds the module at its actual location.');
    $this
      ->assertTrue(strpos($this->getFilenameTestTriggeredError, format_string('The following module has moved within the file system: %name', array(
      '%name' => 'common_test',
    ))) === 0, 'Searching for a module that does not exist in the system table triggers the correct error.');
    restore_error_handler();
    $file_scans = _drupal_file_scan_cache();
    $this
      ->assertIdentical($file_scans['module']['common_test'], 'modules/simpletest/tests/common_test.module', 'Searching for a module that does not exist in the system table creates a record in the missing and moved files static variable.');
    drupal_file_scan_write_cache();
    $cache = cache_get('_drupal_file_scan_cache', 'cache_bootstrap');
    $this
      ->assertIdentical($cache->data['module']['common_test'], 'modules/simpletest/tests/common_test.module', 'Searching for a module that does not exist in the system table creates a record in the missing and moved files persistent cache.');
  }

  /**
   * Skips handling of "file not found" errors.
   */
  public function fileNotFoundErrorHandler($error_level, $message, $filename, $line, $context) {

    // Skip error handling if this is a "file not found" error.
    if (strpos($message, 'is missing from the file system:') !== FALSE || strpos($message, 'has moved within the file system:') !== FALSE) {
      $this->getFilenameTestTriggeredError = $message;
      return;
    }
    _drupal_error_handler($error_level, $message, $filename, $line, $context);
  }

  /**
   * Test that watchdog messages about missing files are correctly recorded.
   */
  public function testWatchdog() {

    // Search for a module that does not exist in either the file system or the
    // {system} table. Make sure that an appropriate warning is recorded in the
    // logs.
    $non_existing_module = $this
      ->randomName();
    $query_parameters = array(
      ':type' => 'php',
      ':severity' => WATCHDOG_WARNING,
    );
    $this
      ->assertEqual(db_query('SELECT COUNT(*) FROM {watchdog} WHERE type = :type AND severity = :severity', $query_parameters)
      ->fetchField(), 0, 'No warning message appears in the logs before searching for a module that does not exist.');

    // Trigger the drupal_get_filename() call. This must be done via a request
    // to a separate URL since the watchdog() will happen in a shutdown
    // function, and so that SimpleTest can be told to ignore (and not fail as
    // a result of) the expected PHP warnings generated during this process.
    variable_set('system_test_drupal_get_filename_test_module_name', $non_existing_module);
    $this
      ->drupalGet('system-test/drupal-get-filename');
    $message_variables = db_query('SELECT variables FROM {watchdog} WHERE type = :type AND severity = :severity', $query_parameters)
      ->fetchCol();
    $this
      ->assertEqual(count($message_variables), 1, 'A single warning message appears in the logs after searching for a module that does not exist.');
    $variables = reset($message_variables);
    $variables = unserialize($variables);
    $this
      ->assertTrue(isset($variables['!message']) && strpos($variables['!message'], format_string('The following module is missing from the file system: %name', array(
      '%name' => $non_existing_module,
    ))) !== FALSE, 'The warning message that appears in the logs after searching for a module that does not exist contains the expected text.');
  }

  /**
   * Test that drupal_get_filename() does not break recursive rebuilds.
   */
  public function testRecursiveRebuilds() {

    // Ensure that the drupal_get_filename() call due to a missing module does
    // not break the data returned by an attempted recursive rebuild. The code
    // path which is tested is as follows:
    // - Call drupal_get_schema().
    // - Within a hook_schema() implementation, trigger a drupal_get_filename()
    //   search for a nonexistent module.
    // - In the watchdog() call that results from that, trigger
    //   drupal_get_schema() again.
    // Without some kind of recursion protection, this could cause the second
    // drupal_get_schema() call to return incomplete results. This test ensures
    // that does not happen.
    $non_existing_module = $this
      ->randomName();
    variable_set('system_test_drupal_get_filename_test_module_name', $non_existing_module);
    $this
      ->drupalGet('system-test/drupal-get-filename-with-schema-rebuild');
    $original_drupal_get_schema_tables = variable_get('system_test_drupal_get_filename_with_schema_rebuild_original_tables');
    $final_drupal_get_schema_tables = variable_get('system_test_drupal_get_filename_with_schema_rebuild_final_tables');
    $this
      ->assertTrue(!empty($original_drupal_get_schema_tables));
    $this
      ->assertTrue(!empty($final_drupal_get_schema_tables));
    $this
      ->assertEqual($original_drupal_get_schema_tables, $final_drupal_get_schema_tables);
  }

}
class BootstrapTimerTestCase extends DrupalUnitTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Timer test',
      'description' => 'Test that timer_read() works both when a timer is running and when a timer is stopped.',
      'group' => 'Bootstrap',
    );
  }

  /**
   * Test timer_read() to ensure it properly accumulates time when the timer
   * started and stopped multiple times.
   * @return
   */
  function testTimer() {
    timer_start('test');
    sleep(1);
    $this
      ->assertTrue(timer_read('test') >= 1000, 'Timer measured 1 second of sleeping while running.');
    sleep(1);
    timer_stop('test');
    $this
      ->assertTrue(timer_read('test') >= 2000, 'Timer measured 2 seconds of sleeping after being stopped.');
    timer_start('test');
    sleep(1);
    $this
      ->assertTrue(timer_read('test') >= 3000, 'Timer measured 3 seconds of sleeping after being restarted.');
    sleep(1);
    $timer = timer_stop('test');
    $this
      ->assertTrue(timer_read('test') >= 4000, 'Timer measured 4 seconds of sleeping after being stopped for a second time.');
    $this
      ->assertEqual($timer['count'], 2, 'Timer counted 2 instances of being started.');
  }

}

/**
 * Test that resetting static variables works.
 */
class BootstrapResettableStaticTestCase extends DrupalUnitTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Resettable static variables test',
      'description' => 'Test that drupal_static() and drupal_static_reset() work.',
      'group' => 'Bootstrap',
    );
  }

  /**
   * Test that a variable reference returned by drupal_static() gets reset when
   * drupal_static_reset() is called.
   */
  function testDrupalStatic() {
    $name = __CLASS__ . '_' . __METHOD__;
    $var =& drupal_static($name, 'foo');
    $this
      ->assertEqual($var, 'foo', 'Variable returned by drupal_static() was set to its default.');

    // Call the specific reset and the global reset each twice to ensure that
    // multiple resets can be issued without odd side effects.
    $var = 'bar';
    drupal_static_reset($name);
    $this
      ->assertEqual($var, 'foo', 'Variable was reset after first invocation of name-specific reset.');
    $var = 'bar';
    drupal_static_reset($name);
    $this
      ->assertEqual($var, 'foo', 'Variable was reset after second invocation of name-specific reset.');
    $var = 'bar';
    drupal_static_reset();
    $this
      ->assertEqual($var, 'foo', 'Variable was reset after first invocation of global reset.');
    $var = 'bar';
    drupal_static_reset();
    $this
      ->assertEqual($var, 'foo', 'Variable was reset after second invocation of global reset.');
  }

}

/**
 * Test miscellaneous functions in bootstrap.inc.
 */
class BootstrapMiscTestCase extends DrupalUnitTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Miscellaneous bootstrap unit tests',
      'description' => 'Test miscellaneous functions in bootstrap.inc.',
      'group' => 'Bootstrap',
    );
  }

  /**
   * Test miscellaneous functions in bootstrap.inc.
   */
  function testMisc() {

    // Test drupal_array_merge_deep().
    $link_options_1 = array(
      'fragment' => 'x',
      'attributes' => array(
        'title' => 'X',
        'class' => array(
          'a',
          'b',
        ),
      ),
      'language' => 'en',
    );
    $link_options_2 = array(
      'fragment' => 'y',
      'attributes' => array(
        'title' => 'Y',
        'class' => array(
          'c',
          'd',
        ),
      ),
      'html' => TRUE,
    );
    $expected = array(
      'fragment' => 'y',
      'attributes' => array(
        'title' => 'Y',
        'class' => array(
          'a',
          'b',
          'c',
          'd',
        ),
      ),
      'language' => 'en',
      'html' => TRUE,
    );
    $this
      ->assertIdentical(drupal_array_merge_deep($link_options_1, $link_options_2), $expected, 'drupal_array_merge_deep() returned a properly merged array.');
  }

  /**
   * Tests that the drupal_check_memory_limit() function works as expected.
   */
  function testCheckMemoryLimit() {
    $memory_limit = ini_get('memory_limit');

    // Test that a very reasonable amount of memory is available.
    $this
      ->assertTrue(drupal_check_memory_limit('30MB'), '30MB of memory tested available.');

    // Get the available memory and multiply it by two to make it unreasonably
    // high.
    $twice_avail_memory = $memory_limit * 2 . 'MB';

    // The function should always return true if the memory limit is set to -1.
    $this
      ->assertTrue(drupal_check_memory_limit($twice_avail_memory, -1), 'drupal_check_memory_limit() returns TRUE when a limit of -1 (none) is supplied');

    // Test that even though we have 30MB of memory available - the function
    // returns FALSE when given an upper limit for how much memory can be used.
    $this
      ->assertFalse(drupal_check_memory_limit('30MB', '16MB'), 'drupal_check_memory_limit() returns FALSE with a 16MB upper limit on a 30MB requirement.');

    // Test that an equal amount of memory to the amount requested returns TRUE.
    $this
      ->assertTrue(drupal_check_memory_limit('30MB', '30MB'), 'drupal_check_memory_limit() returns TRUE when requesting 30MB on a 30MB requirement.');
  }

}

/**
 * Tests for overriding server variables via the API.
 */
class BootstrapOverrideServerVariablesTestCase extends DrupalUnitTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Overriding server variables',
      'description' => 'Test that drupal_override_server_variables() works correctly.',
      'group' => 'Bootstrap',
    );
  }

  /**
   * Test providing a direct URL to to drupal_override_server_variables().
   */
  function testDrupalOverrideServerVariablesProvidedURL() {
    $tests = array(
      'http://example.com' => array(
        'HTTP_HOST' => 'example.com',
        'SCRIPT_NAME' => isset($_SERVER['SCRIPT_NAME']) ? $_SERVER['SCRIPT_NAME'] : NULL,
      ),
      'http://example.com/index.php' => array(
        'HTTP_HOST' => 'example.com',
        'SCRIPT_NAME' => '/index.php',
      ),
      'http://example.com/subdirectory/index.php' => array(
        'HTTP_HOST' => 'example.com',
        'SCRIPT_NAME' => '/subdirectory/index.php',
      ),
    );
    foreach ($tests as $url => $expected_server_values) {

      // Remember the original value of $_SERVER, since the function call below
      // will modify it.
      $original_server = $_SERVER;

      // Call drupal_override_server_variables() and ensure that all expected
      // $_SERVER variables were modified correctly.
      drupal_override_server_variables(array(
        'url' => $url,
      ));
      foreach ($expected_server_values as $key => $value) {
        $this
          ->assertIdentical($_SERVER[$key], $value);
      }

      // Restore the original value of $_SERVER.
      $_SERVER = $original_server;
    }
  }

}

/**
 * Tests for $_GET['destination'] and $_REQUEST['destination'] validation.
 */
class BootstrapDestinationTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'URL destination validation',
      'description' => 'Test that $_GET[\'destination\'] and $_REQUEST[\'destination\'] cannot contain external URLs.',
      'group' => 'Bootstrap',
    );
  }
  function setUp() {
    parent::setUp('system_test');
  }

  /**
   * Tests that $_GET/$_REQUEST['destination'] only contain internal URLs.
   *
   * @see _drupal_bootstrap_variables()
   * @see system_test_get_destination()
   * @see system_test_request_destination()
   */
  public function testDestination() {
    $test_cases = array(
      array(
        'input' => 'node',
        'output' => 'node',
        'message' => "Standard internal example node path is present in the 'destination' parameter.",
      ),
      array(
        'input' => '/example.com',
        'output' => '/example.com',
        'message' => 'Internal path with one leading slash is allowed.',
      ),
      array(
        'input' => '//example.com/test',
        'output' => '',
        'message' => 'External URL without scheme is not allowed.',
      ),
      array(
        'input' => 'example:test',
        'output' => 'example:test',
        'message' => 'Internal URL using a colon is allowed.',
      ),
      array(
        'input' => 'http://example.com',
        'output' => '',
        'message' => 'External URL is not allowed.',
      ),
      array(
        'input' => 'javascript:alert(0)',
        'output' => 'javascript:alert(0)',
        'message' => 'Javascript URL is allowed because it is treated as an internal URL.',
      ),
    );
    foreach ($test_cases as $test_case) {

      // Test $_GET['destination'].
      $this
        ->drupalGet('system-test/get-destination', array(
        'query' => array(
          'destination' => $test_case['input'],
        ),
      ));
      $this
        ->assertIdentical($test_case['output'], $this
        ->drupalGetContent(), $test_case['message']);

      // Test $_REQUEST['destination']. There's no form to submit to, so
      // drupalPost() won't work here; this just tests a direct $_POST request
      // instead.
      $curl_parameters = array(
        CURLOPT_URL => $this
          ->getAbsoluteUrl('system-test/request-destination'),
        CURLOPT_POST => TRUE,
        CURLOPT_POSTFIELDS => 'destination=' . urlencode($test_case['input']),
        CURLOPT_HTTPHEADER => array(),
      );
      $post_output = $this
        ->curlExec($curl_parameters);
      $this
        ->assertIdentical($test_case['output'], $post_output, $test_case['message']);
    }

    // Make sure that 404 pages do not populate $_GET['destination'] with
    // external URLs.
    variable_set('site_404', 'system-test/get-destination');
    $this
      ->drupalGet('http://example.com', array(
      'external' => FALSE,
    ));
    $this
      ->assertIdentical('', $this
      ->drupalGetContent(), 'External URL is not allowed on 404 pages.');
  }

}

Classes

Namesort descending Description
BootstrapAutoloadTestCase Tests the auto-loading behavior of the code registry.
BootstrapDestinationTestCase Tests for $_GET['destination'] and $_REQUEST['destination'] validation.
BootstrapGetFilenameTestCase Test drupal_get_filename()'s availability.
BootstrapGetFilenameWebTestCase Test drupal_get_filename() in the context of a full Drupal installation.
BootstrapIPAddressTestCase
BootstrapMiscTestCase Test miscellaneous functions in bootstrap.inc.
BootstrapOverrideServerVariablesTestCase Tests for overriding server variables via the API.
BootstrapPageCacheTestCase
BootstrapResettableStaticTestCase Test that resetting static variables works.
BootstrapTimerTestCase
BootstrapVariableTestCase
HookBootExitTestCase Test hook_boot() and hook_exit().