class EnableDisableTestCase

class EnableDisableTestCase extends ModuleTestCase {
    protected $profile = 'testing';
    public static function getInfo() {
        return array(
            'name' => 'Enable/disable modules',
            'description' => 'Enable/disable core module and confirm table creation/deletion.',
            'group' => 'Module',
        );
    }
    
    /**
     * Test that all core modules can be enabled, disabled and uninstalled.
     */
    function testEnableDisable() {
        // Try to enable, disable and uninstall all core modules, unless they are
        // hidden or required.
        $modules = system_rebuild_module_data();
        foreach ($modules as $name => $module) {
            if ($module->info['package'] != 'Core' || !empty($module->info['hidden']) || !empty($module->info['required'])) {
                unset($modules[$name]);
            }
        }
        $this->assertTrue(count($modules), format_string('Found @count core modules that we can try to enable in this test.', array(
            '@count' => count($modules),
        )));
        // Enable the dblog module first, since we will be asserting the presence
        // of log messages throughout the test.
        if (isset($modules['dblog'])) {
            $modules = array(
                'dblog' => $modules['dblog'],
            ) + $modules;
        }
        // Set a variable so that the hook implementations in system_test.module
        // will display messages via drupal_set_message().
        variable_set('test_verbose_module_hooks', TRUE);
        // Throughout this test, some modules may be automatically enabled (due to
        // dependencies). We'll keep track of them in an array, so we can handle
        // them separately.
        $automatically_enabled = array();
        // Go through each module in the list and try to enable it (unless it was
        // already enabled automatically due to a dependency).
        foreach ($modules as $name => $module) {
            if (empty($automatically_enabled[$name])) {
                // Start a list of modules that we expect to be enabled this time.
                $modules_to_enable = array(
                    $name,
                );
                // Find out if the module has any dependencies that aren't enabled yet;
                // if so, add them to the list of modules we expect to be automatically
                // enabled.
                foreach (array_keys($module->requires) as $dependency) {
                    if (isset($modules[$dependency]) && empty($automatically_enabled[$dependency])) {
                        $modules_to_enable[] = $dependency;
                        $automatically_enabled[$dependency] = TRUE;
                    }
                }
                // Check that each module is not yet enabled and does not have any
                // database tables yet.
                foreach ($modules_to_enable as $module_to_enable) {
                    $this->assertModules(array(
                        $module_to_enable,
                    ), FALSE);
                    $this->assertModuleTablesDoNotExist($module_to_enable);
                }
                // Install and enable the module.
                $edit = array();
                $edit['modules[Core][' . $name . '][enable]'] = $name;
                $this->drupalPost('admin/modules', $edit, t('Save configuration'));
                // Handle the case where modules were installed along with this one and
                // where we therefore hit a confirmation screen.
                if (count($modules_to_enable) > 1) {
                    $this->drupalPost(NULL, array(), t('Continue'));
                }
                $this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
                // Check that hook_modules_installed() and hook_modules_enabled() were
                // invoked with the expected list of modules, that each module's
                // database tables now exist, and that appropriate messages appear in
                // the logs.
                foreach ($modules_to_enable as $module_to_enable) {
                    $this->assertText(t('hook_modules_installed fired for @module', array(
                        '@module' => $module_to_enable,
                    )));
                    $this->assertText(t('hook_modules_enabled fired for @module', array(
                        '@module' => $module_to_enable,
                    )));
                    $this->assertModules(array(
                        $module_to_enable,
                    ), TRUE);
                    $this->assertModuleTablesExist($module_to_enable);
                    $this->assertLogMessage('system', "%module module installed.", array(
                        '%module' => $module_to_enable,
                    ), WATCHDOG_INFO);
                    $this->assertLogMessage('system', "%module module enabled.", array(
                        '%module' => $module_to_enable,
                    ), WATCHDOG_INFO);
                }
                // Disable and uninstall the original module, and check appropriate
                // hooks, tables, and log messages. (Later, we'll go back and do the
                // same thing for modules that were enabled automatically.) Skip this
                // for the dblog module, because that is needed for the test; we'll go
                // back and do that one at the end also.
                if ($name != 'dblog') {
                    $this->assertSuccessfulDisableAndUninstall($name);
                }
            }
        }
        // Go through all modules that were automatically enabled, and try to
        // disable and uninstall them one by one.
        while (!empty($automatically_enabled)) {
            $initial_count = count($automatically_enabled);
            foreach (array_keys($automatically_enabled) as $name) {
                // If the module can't be disabled due to dependencies, skip it and try
                // again the next time. Otherwise, try to disable it.
                $this->drupalGet('admin/modules');
                $disabled_checkbox = $this->xpath('//input[@type="checkbox" and @disabled="disabled" and @name="modules[Core][' . $name . '][enable]"]');
                if (empty($disabled_checkbox) && $name != 'dblog') {
                    unset($automatically_enabled[$name]);
                    $this->assertSuccessfulDisableAndUninstall($name);
                }
            }
            $final_count = count($automatically_enabled);
            // If all checkboxes were disabled, something is really wrong with the
            // test. Throw a failure and avoid an infinite loop.
            if ($initial_count == $final_count) {
                $this->fail(t('Remaining modules could not be disabled.'));
                break;
            }
        }
        // Disable and uninstall the dblog module last, since we needed it for
        // assertions in all the above tests.
        if (isset($modules['dblog'])) {
            $this->assertSuccessfulDisableAndUninstall('dblog');
        }
        // Now that all modules have been tested, go back and try to enable them
        // all again at once. This tests two things:
        // - That each module can be successfully enabled again after being
        //   uninstalled.
        // - That enabling more than one module at the same time does not lead to
        //   any errors.
        $edit = array();
        foreach (array_keys($modules) as $name) {
            $edit['modules[Core][' . $name . '][enable]'] = $name;
        }
        $this->drupalPost('admin/modules', $edit, t('Save configuration'));
        $this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
    }
    
    /**
     * Ensures entity info cache is updated after changes.
     */
    function testEntityInfoChanges() {
        module_enable(array(
            'entity_cache_test',
        ));
        $entity_info = entity_get_info();
        $this->assertTrue(isset($entity_info['entity_cache_test']), 'Test entity type found.');
        // Change the label of the test entity type and make sure changes appear
        // after flushing caches.
        variable_set('entity_cache_test_label', 'New label.');
        drupal_flush_all_caches();
        $info = entity_get_info('entity_cache_test');
        $this->assertEqual($info['label'], 'New label.', 'New label appears in entity info.');
        // Disable the providing module and make sure the entity type is gone.
        module_disable(array(
            'entity_cache_test',
            'entity_cache_test_dependency',
        ));
        $entity_info = entity_get_info();
        $this->assertFalse(isset($entity_info['entity_cache_test']), 'Entity type of the providing module is gone.');
    }
    
    /**
     * Tests entity info cache after enabling a module with a dependency on an entity providing module.
     *
     * @see entity_cache_test_watchdog()
     */
    function testEntityInfoCacheWatchdog() {
        module_enable(array(
            'entity_cache_test',
        ));
        $info = variable_get('entity_cache_test');
        $this->assertEqual($info['label'], 'Entity Cache Test', 'Entity info label is correct.');
        $this->assertEqual($info['controller class'], 'DrupalDefaultEntityController', 'Entity controller class info is correct.');
    }
    
    /**
     * Disables and uninstalls a module and asserts that it was done correctly.
     *
     * @param $module
     *   The name of the module to disable and uninstall.
     */
    function assertSuccessfulDisableAndUninstall($module) {
        // Disable the module.
        $edit = array();
        $edit['modules[Core][' . $module . '][enable]'] = FALSE;
        $this->drupalPost('admin/modules', $edit, t('Save configuration'));
        $this->assertText(t('The configuration options have been saved.'), 'Modules status has been updated.');
        $this->assertModules(array(
            $module,
        ), FALSE);
        // Check that the appropriate hook was fired and the appropriate log
        // message appears.
        $this->assertText(t('hook_modules_disabled fired for @module', array(
            '@module' => $module,
        )));
        $this->assertLogMessage('system', "%module module disabled.", array(
            '%module' => $module,
        ), WATCHDOG_INFO);
        //  Check that the module's database tables still exist.
        $this->assertModuleTablesExist($module);
        // Uninstall the module.
        $edit = array();
        $edit['uninstall[' . $module . ']'] = $module;
        $this->drupalPost('admin/modules/uninstall', $edit, t('Uninstall'));
        $this->drupalPost(NULL, NULL, t('Uninstall'));
        $this->assertText(t('The selected modules have been uninstalled.'), 'Modules status has been updated.');
        $this->assertModules(array(
            $module,
        ), FALSE);
        // Check that the appropriate hook was fired and the appropriate log
        // message appears. (But don't check for the log message if the dblog
        // module was just uninstalled, since the {watchdog} table won't be there
        // anymore.)
        $this->assertText(t('hook_modules_uninstalled fired for @module', array(
            '@module' => $module,
        )));
        if ($module != 'dblog') {
            $this->assertLogMessage('system', "%module module uninstalled.", array(
                '%module' => $module,
            ), WATCHDOG_INFO);
        }
        // Check that the module's database tables no longer exist.
        $this->assertModuleTablesDoNotExist($module);
    }

}