config.test

<?php
/**
 * @file
 * Tests for Configuration module.
 */

/**
 * Tests reading and writing file contents.
 */
class ConfigurationTest extends BackdropWebTestCase {
  protected function setUp() {
    parent::setUp(array('config_test'));
  }

  /**
   * Tests that a config setting can be written, read and deleted.
   */
  public function testReadWriteClearConfig() {
    // Long-hand setting, getting and deleting.
    $config = config('foo.bar');
    $config->set('foo', 'bar');
    $config->save();
    $this->assertEqual('bar', config('foo.bar')->get('foo'), 'Content retrieved from written config data using Config classes.');
    $config->clear('foo');
    $config->save();
    $this->assertNull(config('foo.bar')->get('foo'), 'Deleted config data cannot be retrieved using Config classes.');

    // Short-hand setting, getting and deleting.
    config_set('foo.bar', 'foo', 'baz');
    $this->assertEqual('baz', config_get('foo.bar', 'foo'), 'Content retrieved from written config data using short cut functions.');
    config_clear('foo.bar', 'foo');
    $this->assertNull(config_get('foo.bar', 'foo'), 'Deleted config data cannot be retrieved using shortcut functions.');
  }

  /**
   * Tests reading existing config files provided by a module.
   */
  public function testExistingConfig() {
    // Get a list of all configuration files by prefix. Note that even doing
    // this check also checks that the configuration provided by a module has
    // been moved into the "active" storage directory when the module was
    // installed.
    $config_names = config_get_names_with_prefix('config_test.group', 'active');
    $expected_names = array(
      'config_test.group.item_1',
      'config_test.group.item_2',
    );
    $this->assertEqual($config_names, $expected_names, 'Existing configuration files found by their prefixes.');

    // Attempt to save a configuration without a name key.
    $item_config = config('config_test.group.item_1');
    try {
      $item_config->validateData();
      $this->pass('Configuration data validated successfully.');
    }
    catch (ConfigValidateException $e) {
      $this->fail('Configuration data unexpectedly failed with the Exception message: ' . $e->getMessage());
    }

    // Attempt to save a configuration without a name key.
    $item_name = $item_config->get('name');
    $item_config->clear('name');
    try {
      $item_config->validateData();
      $this->fail('Configuration data validated unexpectedly when a ConfigValidateException should have been thrown.');
    }
    catch (ConfigValidateException $e) {
      $this->pass('Configuration data validation properly threw a ConfigValidateException when the name was removed.');
    }
    $item_config->set('name', $item_name);

    // Attempt to save a configuration without a label key.
    $item_label = $item_config->get('label');
    $item_config->clear('label');
    try {
      $item_config->validateData();
      $this->fail('Configuration data validated unexpectedly when a ConfigValidateException should have been thrown.');
    }
    catch (ConfigValidateException $e) {
      $this->pass('Configuration data validation properly threw a ConfigValidateException when the label was removed.');
    }
    $item_config->set('label', $item_label);

    // Get an individual configuration.
    $config = config('config_test.simple');
    $expected_config = array(
      'favorite_animal' => 'cats',
      'favorite_color' => 'blue',
    );
    // Test both paths.
    $this->assertEqual($config->get(), $expected_config, 'The configuration file via Config::get() contained the expected configuration.');
    $this->assertEqual($config->getData(), $expected_config, 'The configuration file via Config::getData() contained the expected configuration.');
  }

  /**
   * Tests that a config setting can be overridden.
   */
  public function testOverrideConfig() {
    $original_data = array(
      'foo' => array(
        'key1' => 'value1',
        'key2' => 'value2',
        'key3' => 'value3',
      ),
      'bar' => array(
        'keyA' => 'valueA',
        'keyB' => 'valueB',
      ),
    );

    // Set variable the regular method.
    $config_data = config('config.test');
    $config_data->setData($original_data);
    $config_data->save();

    $this->assertEqual('value1', config('config.test')->get('foo.key1'), 'Sample config retrieved from written config data using Config classes.');
    $this->assertEqual('valueB', config('config.test')->get('bar.keyB'), 'Sample config retrieved from written config data using Config classes.');

    // Simulate overriding in settings file.
    $GLOBALS['config']['config.test']['foo.key1'] = 'chocolate';
    $config_data = config('config.test');
    $this->assertEqual('chocolate', $config_data->get('foo.key1'), 'Config variable overridden in global configuration override.');
    $this->assertTrue(config_is_overridden('config.test', 'foo.key1'), 'Nested config variable is overridden.');
    $this->assertFalse(config_is_overridden('config.test', 'foo'), 'Root config variable not considered overridden.');
    $this->assertEqual($original_data['foo']['key2'], $config_data->get('foo.key2'), 'Sibling key not affected by override.');
    $this->assertEqual($original_data['bar'], $config_data->get('bar'), 'Uncle key not affected by override.');

    // Simulate overriding a collection of values.
    $override_data = array(
      'key1' => 'chocolate',
      'key2' => 'vanilla',
    );
    unset($GLOBALS['config']['config.test']['foo.key1']);
    $GLOBALS['config']['config.test']['foo'] = $override_data;

    $config_data = config('config.test');
    $this->assertEqual('chocolate', $config_data->get('foo.key1'), 'Config variable overridden in global configuration override.');
    $this->assertEqual('vanilla', $config_data->get('foo.key2'), 'Config variable overridden in global configuration override.');
    $this->assertEqual($override_data, $config_data->get('foo'), 'Entire set of nested data overridden. Discarding 3rd undefined key.');
    $this->assertTrue(config_is_overridden('config.test', 'foo.key1'), 'Nested config variable is overridden when overriding parent.');
    $this->assertTrue(config_is_overridden('config.test', 'foo'), 'Root config variable is considered overridden when overriding parent.');

    // Try overwriting the overridden config, which won't actually write.
    $config_data->set('foo.key1', 'chocolate');
    $config_data->save();

    $config_data = config('config.test');
    $this->assertEqual('chocolate', config('config.test')->get('foo.key1'), 'Config variable still overridden and cannot be set regular way.');
    $this->assertEqual($config_data->getOriginal('foo.key1'), 'value1', 'Config original value still in place.');
    $this->assertEqual($config_data->getOverride('foo.key1'), 'chocolate', 'Overridden value retrieved correctly.');

    // Actually overwrite the config with the overridden value.
    $config_data->set('foo.key1', 'chocolate', TRUE);
    $config_data->save();

    // Reload the config to read from disk again, the overridden value should
    // now be on disk.
    unset($GLOBALS['config']['config.test']['foo']);
    $config_data = config('config.test');
    $this->assertEqual(FALSE, $config_data->isOverridden('foo.key1'), 'Original value no longer overridden.');
    $this->assertEqual($config_data->get('foo.key1'), 'chocolate', 'Original value has been updated to include overridden value.');
  }

  /**
   * Tests the in-memory cache used by configuration.
   */
  public function testConfigStaticCache() {
    // Populate a sample configuration file.
    $original_data = array(
      'favorite_animal' => 'cats',
    );
    $config = config('config.test');
    $config->setData($original_data);
    $config->save();

    // Check the default case of not using static caching.
    $this->assertEqual($config->isStatic(), FALSE, 'Configuration is by default not statically cached.');

    $static_cache = &backdrop_static('config');
    $this->assertFalse(array_key_exists('config.test', $static_cache['active']), 'Static cache is empty by default after reading configuration.');

    // Enable static caching and check the in-cache memory is used.
    $config->setStatic();
    $config->save();

    $config = config('config.test');

    $this->assertEqual($config->isStatic(), TRUE, 'Configuration is statically cached after setting static flag.');
    $this->assertNotNull($static_cache['active']['config.test'], 'Static cache is not empty after reading configuration that has the static flag set.');

    // Note the _config_name key is specifically removed when reading. But other
    // _config_* keys should be the first items in the stored data.
    $expected_static_data = array(
      '_config_static' => TRUE,
      'favorite_animal' => 'cats',
    );
    $actual_static_data = $static_cache['active']['config.test']->getData();
    $this->assertIdentical($expected_static_data, $actual_static_data, 'Static cache is set to the expected exact values after reading from disk.');

    /** @noinspection PhpArrayIndexImmediatelyRewrittenInspection */
    $static_cache['active']['config.test']->set('favorite_animal', 'bunnies');
    $config = config('config.test');
    $this->assertEqual($config->get('favorite_animal'), 'bunnies', 'Static cache is used when reading configuration.');

    // Disable static caching and check it is no longer used.
    $config->setStatic(FALSE);
    $config->save();

    $config = config('config.test');
    $this->assertFalse(array_key_exists('config.test', $static_cache['active']), 'Static cache is empty after removing static flag.');
    $this->assertEqual($config->get('favorite_animal'), 'bunnies', 'Original value is read from disk when static flag removed.');
    $this->assertNull($config->get('_config_static'), 'Config static flag entire removed when using setStatic(FALSE).');
  }

  /**
   * Tests that config directories are protected by .htaccess files.
   */
  public function testConfigHtaccess() {
    // This test only run if using file-based config storage.
    $active_storage = config_get_config_storage();
    $active_dir = config_get_config_directory();
    if (!is_a($active_storage, 'ConfigFileStorage')) {
      $this->assert(TRUE, 'Config storage is not file-based, so .htaccess test skipped.');
      return;
    }

    // Visit the status report to confirm the file is re-created automatically.
    $admin_user = $this->backdropCreateUser(array(
      'access administration pages',
      'access site reports',
    ));
    $this->backdropLogin($admin_user);

    // Remove .htaccess file so we can test that it gets re-created.
    @backdrop_unlink($active_dir . '/.htaccess');
    $this->assertFalse(is_file($active_dir . '/.htaccess'), "Removed the .htaccess file in the 'active' config directory.");

    $this->backdropGet('admin/reports/status');
    $this->assertTrue(is_file($active_dir . '/.htaccess'), "Re-created the .htaccess file in the 'active' config directory.");

    // Verify contents of .htaccess file.
    $file = file_get_contents($active_dir . '/.htaccess');
    $this->assertEqual($file, file_htaccess_lines(), 'The .htaccess file contains the proper content.');
  }
}

/**
 * Tests hooks for validation, creating, updating, and deleting configurations.
 */
class ConfigurationHooksTest extends BackdropWebTestCase {
  protected function setUp() {
    parent::setUp(array('config_test', 'config_test_hooks'));
  }

  /**
   * Tests checking the validation hooks.
   *
   * This test does not include a test of hook_config_data_validate() as it is
   * tested by ConfigurationTest::testExistingConfig().
   */
  public function testHooks() {
    $config_data = config_get('config_test.simple');
    module_load_include('inc', 'config', 'config.sync');

    // Check validation.
    $config_data['favorite_animal'] = 'rabbits';
    $errors = array(
      'create' => 'Sorry, only bunnies allowed as favorite animals.',
      'update' => 'Sorry, cats must be preferred over rabbits.',
      'delete' => 'Favorite animals are in use.',
    );
    foreach (array('create', 'update', 'delete') as $op) {
      try {
        config_sync_validate_file('config_test.simple', $op, NULL, $config_data);
        $this->fail('Validation during "' . $op . '" unexpectedly passed when it should have failed.');
      }
      catch (ConfigValidateException $e) {
        $this->assertEqual($errors[$op], $e->getMessage(), 'Validation during "' . $op . '" configuration threw an error correctly.');
      }
    }

    // Check create, update, and delete hooks.
    $expected_data = array(
      'create' =>  array(
        'favorite_animal' => 'rabbits',
        'favorite_color' => 'red',
      ),
      'update' => array(
        'favorite_animal' => 'rabbits',
        'favorite_color' => 'blue',
      ),
      'delete' => array(
        'favorite_animal' => 'cats',
        'favorite_color' => 'blue',
        'deleted_animal' => 'rabbits'
      ),
    );
    foreach (array('create', 'update') as $op) {
      config_sync_file('config_test.new_config', $op, $config_data);
      $new_data = config_get('config_test.new_config');
      $this->assertEqual($expected_data[$op], $new_data, 'Configuration hook for "' . $op . '" executed properly.');
    }

    // The delete hook modifies the "config_test.simple" configuration when the
    // "config_test.new_config" configuration is deleted.
    config_sync_file('config_test.new_config', 'delete');
    $new_data = config_get('config_test.simple');
    $this->assertEqual($expected_data['delete'], $new_data, 'Configuration hook for "delete" executed properly.');
  }
}

/**
 * Tests the UI for syncing, importing, and exporting.
 */
class ConfigurationUITest extends BackdropWebTestCase {

  /**
   * @var User
   */
  protected $webUser;

  function setUp() {
    parent::setUp(array('config_test'));

    $this->webUser = $this->backdropCreateUser(array('synchronize configuration'));
    $this->backdropLogin($this->webUser);
  }

  /**
   * Tests importing configuration.
   */
  function testImport() {
    $name = 'config_test.simple';
    $dynamic_name = 'config_test.dynamic.new';
    $staging_storage = new ConfigFileStorage(config_get_config_directory('staging'));

    $this->backdropGet('admin/config/development/configuration');
    $this->assertText('There are no configuration changes currently staged.');
    $this->assertNoFieldById('edit-submit', t('Import all'));

    // Copy all configuration to staging before modification.
    $this->copyConfig('active', 'staging');

    // Create updated configuration object.
    $favorite_animal = 'Animal ' . $this->randomString();
    $staging_config = config($name, 'staging');
    $staging_config->set('favorite_animal', $favorite_animal);
    $staging_config->save();

    $this->assertIdentical($staging_storage->exists($name), TRUE, $name . ' found.');

    // Create new config.
    $original_dynamic_data = array(
      'id' => 'new',
      'label' => 'New',
      'weight' => 0,
      'status' => TRUE,
    );
    $staging_storage->write($dynamic_name, $original_dynamic_data);
    $this->assertIdentical($staging_storage->exists($dynamic_name), TRUE, $dynamic_name . ' found in staging.');

    // Verify that both appear as ready to import.
    $this->backdropGet('admin/config/development/configuration');
    $this->assertText($name);
    $this->assertText($dynamic_name);
    $this->assertFieldById('edit-submit', t('Import all'));

    // Check that the locking message works when an import is in-progress.
    state_set('config_sync', REQUEST_TIME);
    $this->backdropPost(NULL, array(), t('Import all'));
    $this->assertText('Another request may be synchronizing configuration already or a sync failed unexpectedly.');
    state_del('config_sync');

    // Import and verify that both do not appear anymore.
    $this->backdropPost(NULL, array(), t('Import all'));
    $this->assertNoText($name);
    $this->assertNoText($dynamic_name);
    $this->assertNoFieldById('edit-submit', t('Import all'));

    // Verify that there are no further changes to import.
    $this->assertText('There are no configuration changes currently staged.');

    // Verify configuration has changed.
    $this->assertIdentical($favorite_animal, config_get($name, 'favorite_animal'));

    // Verify that new config exists.
    $this->assertIdentical($original_dynamic_data, config_get($dynamic_name));

    // Create a config that is not declared in hook_config_info().
    $this->copyConfig('active', 'staging');
    $dynamic_name2 = $dynamic_name . '2';
    $staging_storage->write($dynamic_name2, $original_dynamic_data);
    $this->assertIdentical($staging_storage->exists($dynamic_name2), TRUE, $dynamic_name2 . ' found in staging.');

    // Attempt an import which should fail.
    $this->backdropPost('admin/config/development/configuration', array(), t('Import all'));

    // Validation should fail, as this config file is not owned by a module.
    $missing_module_message = 'The configuration "@name" is not owned by any module. Try enabling the module that provides this configuration, then importing again.';
    $error_message = t($missing_module_message, array('@name' => $dynamic_name2));
    $this->assertText($error_message, 'Validation properly prevents import when a config is not declared by a module.');

    // Create a second config that is not declared in hook_config_info().
    $dynamic_name3 = $dynamic_name . '3';
    $staging_storage->write($dynamic_name3, $original_dynamic_data);
    $this->assertIdentical($staging_storage->exists($dynamic_name3), TRUE, $dynamic_name3 . ' found in staging.');

    // Attempt an import which should fail on two missing modules.
    $this->backdropPost('admin/config/development/configuration', array(), t('Import all'));

    // Confirm the error message is shown once for each module that is missing.
    $error_message = t($missing_module_message, array('@name' => $dynamic_name2));
    $this->assertText($error_message, 'Validation prevents import when first module of two missing modules is missing.');
    $error_message = t($missing_module_message, array('@name' => $dynamic_name3));
    $this->assertText($error_message, 'Validation prevents import when second module of two missing modules is missing.');

    // Depend on a real module that is not enabled. This configCopy() includes
    // the config from "config_test" module.
    $this->copyConfig('active', 'staging');

    // Fully uninstall config_test module, which will delete associated config.
    module_disable(array('config_test'));
    backdrop_uninstall_modules(array('config_test'));
    module_list(TRUE);
    $this->assertFalse(module_exists('config_test'), 'The config_test module has been disabled.');

    // Do not include the config_test module being enabled in the first import.
    $system_extensions_data = $staging_storage->read('system.extensions');
    $system_extensions_data['modules']['config_test'] = FALSE;
    $staging_storage->write('system.extensions', $system_extensions_data);

    // Attempt an import which should fail on the disabled module.
    $this->backdropPost('admin/config/development/configuration', array(), t('Import all'));
    $error_message = t($missing_module_message, array('@name' => 'config_test.simple'));
    $this->assertText($error_message, 'Validation prevents import when depending on a disabled module.');

    // Intentionally create an error in the configuration file so that it will
    // be flagged as invalid by config_test module, even though it is disabled
    // before the start of the sync process.
    $config_test_data = $staging_storage->read('config_test.simple');
    $config_test_data['fail_validation'] = TRUE;
    $staging_storage->write('config_test.simple', $config_test_data);

    // Include the dependent module in system.extensions so it is enabled as
    // part of the config sync.
    $system_extensions_data['modules']['config_test'] = TRUE;
    $staging_storage->write('system.extensions', $system_extensions_data);

    // Validation should now fail from hook_config_data_validate().
    $this->backdropPost('admin/config/development/configuration', array(), t('Import all'));
    $this->assertText('Configuration intentionally flagged to fail validation.', 'Config sync correctly failed when a disabled module was enabled via system.extensions, then dependent configuration failed validation.');

    // Allow validation to pass by removing the intentional fail flag.
    $config_test_data['fail_validation'] = FALSE;
    $staging_storage->write('config_test.simple', $config_test_data);

    // Now the import should succeed with the dependent module enabled.
    $this->backdropPost('admin/config/development/configuration', array(), t('Import all'));
    $error_message = t($missing_module_message, array('@name' => 'config_test'));
    $this->assertNoText($error_message, 'No validation error when config that has a dependent module is enabled in the same config sync.');
    $this->assertText('Configuration sync completed.', 'Sync successful when enabling a module and its dependent configuration.');

    module_list(TRUE);
    $this->assertTrue(module_exists('config_test'), 'The config_test module was enabled as part of the config sync.');

    // Empty out the staging config.
    $staging_storage->deleteAll();
  }

  /**
   * Tests the screen that shows differences between active and staging.
   */
  function testDiff() {
    $staging_storage = new ConfigFileStorage(config_get_config_directory('staging'));

    $config_name = 'config_test.simple';
    $change_key = 'favorite_animal';
    $remove_key = 'favorite_color';
    $add_key = 'favorite_day';
    $add_data = 'friday';
    $change_data = 'bunnies';
    $original_data = array(
      'favorite_animal' => 'cats',
      'favorite_color' => 'blue',
    );

    // Copy all configuration to staging before modification.
    $this->copyConfig('active', 'staging');

    // Change a configuration value in staging.
    $staging_data = $original_data;
    $staging_data[$change_key] = $change_data;
    $staging_data[$add_key] = $add_data;
    unset($staging_data[$remove_key]);
    $staging_storage->write($config_name, $staging_data);

    // Load the diff UI and verify that the diff reflects the changes.
    $this->backdropGet('admin/config/development/configuration/sync/diff/' . $config_name);
    $deleted_words = $this->xpath('//td[contains(@class, :class)]//del', array(':class' => 'diff-deletedline'));
    $this->assertEqual($original_data[$change_key], (string) $deleted_words[0]);
    $this->assertEqual($remove_key, (string) $deleted_words[1]);
    $this->assertEqual($original_data[$remove_key], (string) $deleted_words[2]);

    $added_words = $this->xpath('//td[contains(@class, :class)]//ins', array(':class' => 'diff-addedline'));
    $this->assertEqual($change_data, (string) $added_words[0]);
    $this->assertEqual($add_key, (string) $added_words[1]);
    $this->assertEqual($add_data, (string) $added_words[2]);
  }

  /**
   * Tests export of configuration.
   */
  function testExport() {
    // Verify the export page with export submit button is available.
    $this->backdropGet('admin/config/development/configuration/full/export');
    $this->assertFieldById('edit-submit', t('Export'));

    // Submit the export form and verify response.
    $this->backdropPost('admin/config/development/configuration/full/export', array(), t('Export'));
    $this->assertResponse(200, 'User can access the download callback.');

    // Get the archived binary file provided to user for download.
    $archive_data = $this->backdropGetContent();

    // Verify the generated archive was removed from the temporary directory
    // after being sent to the user.
    $leftover_files = file_scan_directory('temporary://', '/^config.*\.tar\.gz$/', array('recurse' => FALSE));
    $this->assertTrue(empty($leftover_files), 'Exported archive was removed from the temporary directory after download.');

    // Temporarily save the archive file.
    $uri = 'temporary://config.tar.gz';
    file_put_contents($uri, $archive_data);

    // Verify a user with permission may download the archive from the
    // temporary directory, but anonymous users may not.
    $this->backdropGet(file_create_url($uri));
    $this->assertResponse(200, 'User with permission can download config.tar.gz from the temporary directory.');
    $this->backdropLogout();
    $this->backdropGet(file_create_url($uri));
    $this->assertResponse(403, 'Anonymous user cannot download config.tar.gz from the temporary directory.');
    $this->assertNotEqual($this->backdropGetContent(), $archive_data, 'Archive contents not provided to anonymous user.');

    // Extract the archive and verify it's not empty.
    $file_path = file_directory_temp() . '/' . file_uri_target($uri);
    $archiver = new Archive_Tar($file_path);
    $archive_contents = $archiver->listContent();
    $archive_files = array();
    foreach ($archive_contents as $file) {
      $archive_files[] = $file['filename'];
    }
    $this->assert(!empty($archive_files), 'Downloaded archive file is not empty.');

    // Prepare the list of config files from active storage.
    $storage_active = config_get_config_storage('active');
    $config_files = array();
    foreach ($storage_active->listAll() as $config_name) {
      $config_files[] = $config_name . '.json';
    }
    // Assert that the downloaded archive file contents are the same as the test
    // site active store.
    $this->assertIdentical($archive_files, $config_files, 'Downloaded archive contains all active configuration files.');

    // Delete the archive.
    unlink($uri);
  }

  /**
   * Test full import validation.
   */
  function testFullImportValidation() {
    // Enable all non-test core modules to populate all default config files.
    $core_modules = db_query("SELECT name FROM {system} WHERE type = 'module' AND filename LIKE 'core/modules%' AND filename NOT LIKE '%/tests/%'")->fetchCol();
    module_enable($core_modules);

    // Submit the export form and verify response.
    $this->backdropPost('admin/config/development/configuration/full/export', array(), t('Export'));
    $this->assertResponse(200, 'User can access the download callback.');

    // Get the archived binary file provided to user for download.
    $archive_data = $this->backdropGetContent();

    // Save the archive file.
    $uri = 'temporary://config.tar.gz';
    file_put_contents($uri, $archive_data);
    $realpath = backdrop_realpath($uri);

    // Expand the archive file to modify its contents.
    $directory = 'temporary://' . basename($uri, '.tar.gz');
    $archiver = new Archive_Tar($realpath);
    file_prepare_directory($directory, FILE_CREATE_DIRECTORY);
    $archiver->extract($directory);

    // Delete the old archive.
    unset($archiver);
    unlink($uri);

    // Modify each and every config file.
    $files = file_scan_directory($directory, '/.*\.json/');
    foreach ($files as $filepath => $file) {
      $config_data = json_decode(file_get_contents($filepath), TRUE);
      // The Layout and TaxonomyVocabulary class don't allow dynamic properties.
      if (strpos($file->name, 'layout.layout.') === 0) {
        $config_data['layout_template'] = 'simmons';
      }
      elseif (strpos($file->name, 'taxonomy.vocabulary.') === 0) {
        $config_data['description'] = 'config_test_addition';
      }
      else {
        $config_data['config_test_addition'] = 'test';
      }
      file_put_contents($filepath, backdrop_json_encode($config_data, TRUE));
    }

    // Add back into the archive.
    $archiver = new Archive_Tar($realpath);
    $archiver->createModify(array_keys($files), '', $directory);

    // Delete the modified files.
    file_unmanaged_delete_recursive($directory);

    // Upload the archive into the import form.
    $edit = array(
      'files[import_tarball]' => $uri,
    );
    $this->backdropPost('admin/config/development/configuration/full', $edit, t('Stage import'));

    // Delete the new archive.
    unlink($uri);

    $this->backdropGet('admin/config/development/configuration');

    // Check that every config file is changed.
    foreach ($files as $file) {
      $this->assertText(str_replace('.json', '', $file->filename), format_string('Config file "@file" staged for import.', array('@file' => $file->filename)));
    }

    $this->backdropPost(NULL, array(), t('Import all'));

    // Confirm the import was successful.
    $this->assertText(t('Configuration sync completed. @files configuration files synced.', array('@files' => count($files))));

    // Display any errors directly as a failure.
    $errors = $this->xpath('//div[@id="messages"]//div[contains(@class, "error")]');
    if (count($errors)) {
      $this->fail(strip_tags($errors[0]->asXML()));
    }
  }

  /**
   * Test skipping the clearing of the staging directory after import.
   */
  public function testClearStagingDirectory() {
    $staging_storage = new ConfigFileStorage(config_get_config_directory('staging'));

    // Copy active to staging
    $this->copyConfig('active', 'staging');

    // Set staging system.core so it doesn't clear the staging directory.
    $staging_config = config('system.core', 'staging');
    $staging_config->set('config_sync_clear_staging', 0);
    $staging_config->save();

    // Verify that both appear as ready to import.
    $this->backdropGet('admin/config/development/configuration');
    $this->assertText('system.core');

    // Sync changes
    $this->backdropPost(NULL, array(), t('Import all'));

    // Assert that staging directory is not empty.
    $staging_files = $staging_storage->listAll();
    $this->assert(!empty($staging_files), 'Staging directory is not empty.');
  }

  /**
   * Test comparing configs whose elements are in different order.
   */
  public function testConfigOrderChange() {
    $config_name = 'foo.bar';
    $content = array(
      'a' => 'Foo',
      'b' => 'Bar',
    );
    $config = config($config_name);
    $config->setData($content);
    $config->save();

    // Copy all configuration to staging before modification.
    $this->copyConfig('active', 'staging');

    // Reverse the content of the array.
    krsort($content);

    // Store the reversed config.
    $config->setData($content);
    $config->save();

    // Verify that the file appears as ready to import.
    $this->backdropGet('admin/config/development/configuration');
    $this->assertText($config_name, 'The configuration name appears in the list of changed configurations.');
  }

  /**
   * Copies configuration objects from source storage to target storage.
   *
   * @param string $source
   *   The source config storage name.
   * @param string $target
   *   The target config storage name.
   */
  public function copyConfig($source = 'active', $target = 'staging') {
    $source_storage = config_get_config_storage($source);
    $target_storage = config_get_config_storage($target);
    $target_storage->deleteAll();
    foreach ($source_storage->listAll() as $name) {
      $target_storage->write($name, $source_storage->read($name));
    }
  }
}

/**
 * Tests that hook_config_create() is run during installation of default config.
 */
class ConfigurationInstallDefaultHooksTest extends BackdropWebTestCase {
  protected $profile = 'testing';

  /**
   * @var User
   */
  protected $admin_user;

  protected function setUp() {
    parent::setUp(array('config_test_hooks'));

    // Create a blank content type into which our new config-based field will be
    // added.
    $this->backdropCreateContentType(array(
      'type' => 'post',
      'name' => 'Post',
    ));

    $this->admin_user = $this->backdropCreateUser(array(
      'access administration pages',
      'bypass node access',
      'administer nodes',
      'create post content',
      'edit any post content',
    ));
  }

  /**
   * Tests that hook_config_create() is run during module installation.
   */
  public function testModuleInstall() {
    $config_data = config_get('config_test_hooks.data');
    $this->assertEqual('brie', $config_data['favorite_cheese'], 'Config variable is set to brie.');
    $this->assertFalse(field_info_field('field_config_test'), 'The test field does not exist.');

    module_enable(array('config_test'));
    // Test that config value is altered when default config is synced from
    // another module.
    $config_data = config_get('config_test_hooks.data');
    $this->assertEqual('cheddar', $config_data['favorite_cheese'], 'Config variable is set to cheddar.');
    $this->assertTrue(field_info_field('field_config_test'), 'The test field has been installed.');

    // Test that content can actually be saved into the new field that was
    // created.
    $this->backdropLogin($this->admin_user);
    $this->backdropPost('node/add/post', array(
      'title' => 'Test post',
      'field_config_test[und][0][value]' => 'Test value in the new field',
    ), t('Save'));

    $this->assertText('Post Test post has been created.');
    $this->assertText('Test value in the new field');
  }
}