drupal/modules/simpletest/tests/module.test

<?php
// $Id$

/**
 * @file
 * Tests for the module API.
 */

/**
 * Unit tests for the module API.
 */
class ModuleUnitTest extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Module API',
      'description' => 'Test low-level module functions.',
      'group' => 'Module',
    );
  }

  /**
   * The basic functionality of module_list().
   */
  function testModuleList() {
    // Build a list of modules, sorted alphabetically.
    $profile_info = install_profile_info('standard', 'en');
    $module_list = $profile_info['dependencies'];

    // Install profile is a module that is expected to be loaded.
    $module_list[] = 'standard';

    sort($module_list);
    // Compare this list to the one returned by module_list(). We expect them
    // to match, since all default profile modules have a weight equal to 0
    // (except for block.module, which has a lower weight but comes first in
    // the alphabet anyway).
    $this->assertModuleList($module_list, t('Standard profile'));

    // Try to install a new module.
    module_enable(array('contact'));
    $module_list[] = 'contact';
    sort($module_list);
    $this->assertModuleList($module_list, t('After adding a module'));

    // Try to mess with the module weights.
    db_update('system')
      ->fields(array('weight' => 20))
      ->condition('name', 'contact')
      ->condition('type', 'module')
      ->execute();
    // Reset the module list.
    module_list(TRUE);
    // Move contact to the end of the array.
    unset($module_list[array_search('contact', $module_list)]);
    $module_list[] = 'contact';
    $this->assertModuleList($module_list, t('After changing weights'));

    // Test the fixed list feature.
    $fixed_list = array(
      'system' => array('filename' => drupal_get_path('module', 'system')),
      'menu' => array('filename' => drupal_get_path('module', 'menu')),
    );
    module_list(FALSE, FALSE, FALSE, $fixed_list);
    $new_module_list = array_combine(array_keys($fixed_list), array_keys($fixed_list));
    $this->assertModuleList($new_module_list, t('When using a fixed list'));

    // Reset the module list.
    module_list(TRUE);
    $this->assertModuleList($module_list, t('After reset'));
  }

  /**
   * Assert that module_list() return the expected values.
   *
   * @param $expected_values
   *   The expected values, sorted by weight and module name.
   */
  protected function assertModuleList(Array $expected_values, $condition) {
    $expected_values = array_combine($expected_values, $expected_values);
    $this->assertEqual($expected_values, module_list(), t('@condition: module_list() returns correct results', array('@condition' => $condition)));
    ksort($expected_values);
    $this->assertIdentical($expected_values, module_list(FALSE, FALSE, TRUE), t('@condition: module_list() returns correctly sorted results', array('@condition' => $condition)));
  }

  /**
   * Test module_implements() caching.
   */
  function testModuleImplements() {
    // Clear the cache.
    cache_clear_all('module_implements', 'cache_bootstrap');
    $this->assertFalse(cache_get('module_implements', 'cache_bootstrap'), t('The module implements cache is empty.'));
    $this->drupalGet('');
    $this->assertTrue(cache_get('module_implements', 'cache_bootstrap'), t('The module implements cache is populated after requesting a page.'));

    // Test again with an authenticated user.
    $this->user = $this->drupalCreateUser();
    $this->drupalLogin($this->user);
    cache_clear_all('module_implements', 'cache_bootstrap');
    $this->drupalGet('');
    $this->assertTrue(cache_get('module_implements', 'cache_bootstrap'), t('The module implements cache is populated after requesting a page.'));

    // Make sure group include files are detected properly even when the file is
    // already loaded when the cache is rebuilt.
    // For that activate the module_test which provides the file to load.
    module_enable(array('module_test'));

    module_load_include('inc', 'module_test', 'module_test.file');
    $modules = module_implements('test_hook');
    $static = drupal_static('module_implements');
    $this->assertTrue(in_array('module_test', $modules), 'Hook found.');
    $this->assertEqual($static['test_hook']['module_test'], 'file', 'Include file detected.');
  }

  /**
   * Test dependency resolution.
   */
  function testDependencyResolution() {
    module_enable(array('module_test'), FALSE);
    $this->assertTrue(module_exists('module_test'), t('Test module is enabled.'));

    // First, create a fake missing dependency. Forum depends on poll, which
    // depends on a made-up module, foo. Nothing should be installed.
    variable_set('dependency_test', 'missing dependency');
    $result = module_enable(array('forum'));
    $this->assertFalse($result, t('module_enable() returns FALSE if dependencies are missing.'));
    $this->assertFalse(module_exists('forum'), t('module_enable() aborts if dependencies are missing.'));

    // Now, fix the missing dependency. module_enable() should work.
    variable_set('dependency_test', 'dependency');
    $result = module_enable(array('forum'));
    $this->assertTrue($result, t('module_enable() returns the correct value.'));
    // Verify that the fake dependency chain was installed.
    $this->assertTrue(module_exists('poll') && module_exists('php'), t('Dependency chain was installed by module_enable().'));
    // Finally, verify that the original module was installed.
    $this->assertTrue(module_exists('forum'), t('Module installation with unlisted dependencies succeeded.'));
  }
}

/**
 * Unit tests for module installation.
 */
class ModuleInstallTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Module installation',
      'description' => 'Tests the installation of modules.',
      'group' => 'Module',
    );
  }

  function setUp() {
    parent::setUp('module_test');
  }

  /**
   * Test that calls to drupal_write_record() work during module installation.
   *
   * This is a useful function to test because modules often use it to insert
   * initial data in their database tables when they are being installed or
   * enabled. Furthermore, drupal_write_record() relies on the module schema
   * information being available, so this also checks that the data from one of
   * the module's hook implementations, in particular hook_schema(), is
   * properly available during this time. Therefore, this test helps ensure
   * that modules are fully functional while Drupal is installing and enabling
   * them.
   */
  function testDrupalWriteRecord() {
    // Check for data that was inserted using drupal_write_record() while the
    // 'module_test' module was being installed and enabled.
    $data = db_query("SELECT data FROM {module_test}")->fetchCol();
    $this->assertTrue(in_array('Data inserted in hook_install()', $data), t('Data inserted using drupal_write_record() in hook_install() is correctly saved.'));
    $this->assertTrue(in_array('Data inserted in hook_enable()', $data), t('Data inserted using drupal_write_record() in hook_enable() is correctly saved.'));
  }
}

/**
 * Unit tests for module uninstallation and related hooks.
 */
class ModuleUninstallTestCase extends DrupalWebTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Module uninstallation',
      'description' => 'Tests the uninstallation of modules.',
      'group' => 'Module',
    );
  }

  function setUp() {
    parent::setUp('module_test', 'user');
  }

  /**
   * Tests the hook_modules_uninstalled() of the user module.
   */
  function testUserPermsUninstalled() {
    // Uninstalls the module_test module, so hook_modules_uninstalled()
    // is executed.
    module_disable(array('module_test'));
    drupal_uninstall_modules(array('module_test'));

    // Are the perms defined by module_test removed from {role_permission}.
    $count = db_query("SELECT COUNT(rid) FROM {role_permission} WHERE permission = :perm", array(':perm' => 'module_test perm'))->fetchField();
    $this->assertEqual(0, $count, t('Permissions were all removed.'));
  }
}