module.test

<?php


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

/**
 * Unit tests for the module API.
 */
class ModuleUnitTest extends DrupalWebTestCase {
    protected $user;
    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'));
        // Verify that the module_list() returns correct bootstrap modules.
        $bootstrap_module_list = module_list(TRUE, TRUE);
        $expected_bootstrap_modules = db_query("SELECT name, filename FROM {system} WHERE status = 1 AND bootstrap = 1 AND type = 'module' ORDER BY weight ASC, name ASC")->fetchAllAssoc('name');
        $expected_bootstrap_module_list = array_combine(array_keys($expected_bootstrap_modules), array_keys($expected_bootstrap_modules));
        $this->assertIdentical($expected_bootstrap_module_list, $bootstrap_module_list, 'module_list() returns correct bootstrap modules.');
    }
    
    /**
     * 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 system_modules() with a module with a dependency with a null version.
     */
    function testSystemModulesNullVersion() {
        module_enable(array(
            'system_requires_null_version_test',
        ), FALSE);
        $this->resetAll();
        $admin = $this->drupalCreateUser(array(
            'administer modules',
        ));
        $this->drupalLogin($admin);
        $this->drupalGet('admin/modules');
        $this->assertText('System null version test', 'Module admin UI listed dependency with null version successfully.');
    }
    
    /**
     * Test system_modules() with a module with a broken configure path.
     */
    function testSystemModulesBrokenConfigure() {
        module_enable(array(
            'system_admin_test',
        ));
        $this->resetAll();
        $admin = $this->drupalCreateUser(array(
            'administer modules',
        ));
        $this->drupalLogin($admin);
        $this->drupalGet('admin/modules');
        $module_log = db_query_range('SELECT message FROM {watchdog} WHERE type = :type ORDER BY wid DESC', 0, 1, array(
            ':type' => 'system',
        ))->fetchField();
        $this->assertEqual('Module %module specifies an invalid path for configuration: %configure', $module_log, 'An error was logged for the module\'s broken configure path.');
    }
    
    /**
     * 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.');
    }

}