<?php

/**

 * @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'];

    // Installation 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(), format_string('@condition: module_list() returns correct results', array('@condition' => $condition)));

    ksort($expected_values);

    $this->assertIdentical($expected_values, module_list(FALSE, FALSE, TRUE), format_string('@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'), 'The module implements cache is empty.');

    $this->drupalGet('');

    $this->assertTrue(cache_get('module_implements', 'cache_bootstrap'), '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'), '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 that module_invoke() can load a hook defined in hook_hook_info().

   */

  function testModuleInvoke() {

    module_enable(array('module_test'), FALSE);

    $this->resetAll();

    $this->drupalGet('module-test/hook-dynamic-loading-invoke');

    $this->assertText('success!', 'module_invoke() dynamically loads a hook defined in hook_hook_info().');

  }

  /**

   * Test that module_invoke_all() can load a hook defined in hook_hook_info().

   */

  function testModuleInvokeAll() {

    module_enable(array('module_test'), FALSE);

    $this->resetAll();

    $this->drupalGet('module-test/hook-dynamic-loading-invoke-all');

    $this->assertText('success!', 'module_invoke_all() dynamically loads a hook defined in hook_hook_info().');

  }

  /**

   * Test dependency resolution.

   */

  function testDependencyResolution() {

    // Enable the test module, and make sure that other modules we are testing

    // are not already enabled. (If they were, the tests below would not work

    // correctly.)

    module_enable(array('module_test'), FALSE);

    $this->assertTrue(module_exists('module_test'), 'Test module is enabled.');

    $this->assertFalse(module_exists('forum'), 'Forum module is disabled.');

    $this->assertFalse(module_exists('poll'), 'Poll module is disabled.');

    $this->assertFalse(module_exists('php'), 'PHP module is disabled.');

    // 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');

    drupal_static_reset('system_rebuild_module_data');

    $result = module_enable(array('forum'));

    $this->assertFalse($result, 'module_enable() returns FALSE if dependencies are missing.');

    $this->assertFalse(module_exists('forum'), 'module_enable() aborts if dependencies are missing.');

    // Now, fix the missing dependency. Forum module depends on poll, but poll

    // depends on the PHP module. module_enable() should work.

    variable_set('dependency_test', 'dependency');

    drupal_static_reset('system_rebuild_module_data');

    $result = module_enable(array('forum'));

    $this->assertTrue($result, 'module_enable() returns the correct value.');

    // Verify that the fake dependency chain was installed.

    $this->assertTrue(module_exists('poll') && module_exists('php'), 'Dependency chain was installed by module_enable().');

    // Verify that the original module was installed.

    $this->assertTrue(module_exists('forum'), 'Module installation with unlisted dependencies succeeded.');

    // Finally, verify that the modules were enabled in the correct order.

    $this->assertEqual(variable_get('test_module_enable_order', array()), array('php', 'poll', 'forum'), 'Modules were enabled in the correct order by module_enable().');

    // Now, disable the PHP module. Both forum and poll should be disabled as

    // well, in the correct order.

    module_disable(array('php'));

    $this->assertTrue(!module_exists('forum') && !module_exists('poll'), 'Depedency chain was disabled by module_disable().');

    $this->assertFalse(module_exists('php'), 'Disabling a module with unlisted dependents succeeded.');

    $this->assertEqual(variable_get('test_module_disable_order', array()), array('forum', 'poll', 'php'), 'Modules were disabled in the correct order by module_disable().');

    // Disable a module that is listed as a dependency by the installation

    // profile. Make sure that the profile itself is not on the list of

    // dependent modules to be disabled.

    $profile = drupal_get_profile();

    $info = install_profile_info($profile);

    $this->assertTrue(in_array('comment', $info['dependencies']), 'Comment module is listed as a dependency of the installation profile.');

    $this->assertTrue(module_exists('comment'), 'Comment module is enabled.');

    module_disable(array('comment'));

    $this->assertFalse(module_exists('comment'), 'Comment module was disabled.');

    $disabled_modules = variable_get('test_module_disable_order', array());

    $this->assertTrue(in_array('comment', $disabled_modules), 'Comment module is in the list of disabled modules.');

    $this->assertFalse(in_array($profile, $disabled_modules), 'The installation profile is not in the list of disabled modules.');

    // Try to uninstall the PHP module by itself. This should be rejected,

    // since the modules which it depends on need to be uninstalled first, and

    // that is too destructive to perform automatically.

    $result = drupal_uninstall_modules(array('php'));

    $this->assertFalse($result, 'Calling drupal_uninstall_modules() on a module whose dependents are not uninstalled fails.');

    foreach (array('forum', 'poll', 'php') as $module) {

      $this->assertNotEqual(drupal_get_installed_schema_version($module), SCHEMA_UNINSTALLED, format_string('The @module module was not uninstalled.', array('@module' => $module)));

    }

    // Now uninstall all three modules explicitly, but in the incorrect order,

    // and make sure that drupal_uninstal_modules() uninstalled them in the

    // correct sequence.

    $result = drupal_uninstall_modules(array('poll', 'php', 'forum'));

    $this->assertTrue($result, 'drupal_uninstall_modules() returns the correct value.');

    foreach (array('forum', 'poll', 'php') as $module) {

      $this->assertEqual(drupal_get_installed_schema_version($module), SCHEMA_UNINSTALLED, format_string('The @module module was uninstalled.', array('@module' => $module)));

    }

    $this->assertEqual(variable_get('test_module_uninstall_order', array()), array('forum', 'poll', 'php'), 'Modules were uninstalled in the correct order by drupal_uninstall_modules().');

    // Uninstall the profile module from above, and make sure that the profile

    // itself is not on the list of dependent modules to be uninstalled.

    $result = drupal_uninstall_modules(array('comment'));

    $this->assertTrue($result, 'drupal_uninstall_modules() returns the correct value.');

    $this->assertEqual(drupal_get_installed_schema_version('comment'), SCHEMA_UNINSTALLED, 'Comment module was uninstalled.');

    $uninstalled_modules = variable_get('test_module_uninstall_order', array());

    $this->assertTrue(in_array('comment', $uninstalled_modules), 'Comment module is in the list of uninstalled modules.');

    $this->assertFalse(in_array($profile, $uninstalled_modules), 'The installation profile is not in the list of uninstalled modules.');

    // Enable forum module again, which should enable both the poll module and

    // php module. But, this time do it with poll module declaring a dependency

    // on a specific version of php module in its info file. Make sure that

    // module_enable() still works.

    variable_set('dependency_test', 'version dependency');

    drupal_static_reset('system_rebuild_module_data');

    $result = module_enable(array('forum'));

    $this->assertTrue($result, 'module_enable() returns the correct value.');

    // Verify that the fake dependency chain was installed.

    $this->assertTrue(module_exists('poll') && module_exists('php'), 'Dependency chain was installed by module_enable().');

    // Verify that the original module was installed.

    $this->assertTrue(module_exists('forum'), 'Module installation with version dependencies succeeded.');

    // Finally, verify that the modules were enabled in the correct order.

    $enable_order = variable_get('test_module_enable_order', array());

    $php_position = array_search('php', $enable_order);

    $poll_position = array_search('poll', $enable_order);

    $forum_position = array_search('forum', $enable_order);

    $php_before_poll = $php_position !== FALSE && $poll_position !== FALSE && $php_position < $poll_position;

    $poll_before_forum = $poll_position !== FALSE && $forum_position !== FALSE && $poll_position < $forum_position;

    $this->assertTrue($php_before_poll && $poll_before_forum, 'Modules were enabled in the correct order by module_enable().');

  }

}

/**

 * 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), 'Data inserted using drupal_write_record() in hook_install() is correctly saved.');

    $this->assertTrue(in_array('Data inserted in hook_enable()', $data), '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, 'Permissions were all removed.');

  }

}

class ModuleImplementsAlterTestCase extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Module implements alter',

      'description' => 'Tests hook_module_implements_alter().',

      'group' => 'Module',

    );

  }

  /**

   * Tests hook_module_implements_alter() adding an implementation.

   */

  function testModuleImplementsAlter() {

    module_enable(array('module_test'), FALSE);

    $this->assertTrue(module_exists('module_test'), 'Test module is enabled.');

    // Assert that module_test.module is now included.

    $this->assertTrue(function_exists('module_test_permission'),

      'The file module_test.module was successfully included.');

    $modules = module_implements('permission');

    $this->assertTrue(in_array('module_test', $modules), 'module_test implements hook_permission.');

    $modules = module_implements('module_implements_alter');

    $this->assertTrue(in_array('module_test', $modules), 'module_test implements hook_module_implements_alter().');

    // Assert that module_test.implementations.inc is not included yet.

    $this->assertFalse(function_exists('module_test_altered_test_hook'),

      'The file module_test.implementations.inc is not included yet.');

    // Assert that module_test_module_implements_alter(*, 'altered_test_hook')

    // has added an implementation

    $this->assertTrue(in_array('module_test', module_implements('altered_test_hook')),

      'module_test implements hook_altered_test_hook().');

    // Assert that module_test.implementations.inc was included as part of the process.

    $this->assertTrue(function_exists('module_test_altered_test_hook'),

      'The file module_test.implementations.inc was included.');

  }

}