upgrade.test 10.7 KB
Newer Older
1
2
3
4
5
6
7
8
<?php

/**
 * Perform end-to-end tests of the upgrade path.
 */
abstract class UpgradePathTestCase extends DrupalWebTestCase {

  /**
9
10
11
   * The file path(s) to the dumped database(s) to load into the child site.
   *
   * @var array
12
   */
13
  var $databaseDumpFiles = array();
14
15
16
17
18
19
20
21
22
23
24

  /**
   * Flag that indicates whether the child site has been upgraded.
   */
  var $upgradedSite = FALSE;

  /**
   * Array of errors triggered during the upgrade process.
   */
  var $upgradeErrors = array();

25
26
27
28
29
  /**
   * Array of modules loaded when the test starts.
   */
  var $loadedModules = array();

30
31
32
33
  /**
   * Override of DrupalWebTestCase::setUp() specialized for upgrade testing.
   */
  protected function setUp() {
34
    global $user, $language, $conf;
35

36
37
38
39
40
41
42
43
    // We are going to set a missing zlib requirement property for usage during
    // the performUpgrade() and tearDown() calls. Also set that the tests failed.
    if (!function_exists('gzopen')) {
      $this->missing_zlib_requirement = TRUE;
      parent::setUp();
      return;
    }

44
45
46
    // Load the Update API.
    require_once DRUPAL_ROOT . '/includes/update.inc';

47
48
49
50
    // Reset flags.
    $this->upgradedSite = FALSE;
    $this->upgradeErrors = array();

51
52
    $this->loadedModules = module_list();

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
    // Generate a temporary prefixed database to ensure that tests have a clean starting point.
    $this->databasePrefix = 'simpletest' . mt_rand(1000, 1000000);
    db_update('simpletest_test_id')
      ->fields(array('last_prefix' => $this->databasePrefix))
      ->condition('test_id', $this->testId)
      ->execute();

    // Clone the current connection and replace the current prefix.
    $connection_info = Database::getConnectionInfo('default');
    Database::renameConnection('default', 'simpletest_original_default');
    foreach ($connection_info as $target => $value) {
      $connection_info[$target]['prefix'] = array(
        'default' => $value['prefix']['default'] . $this->databasePrefix,
      );
    }
    Database::addConnectionInfo('default', 'default', $connection_info['default']);

70
71
72
    // Store necessary current values before switching to prefixed database.
    $this->originalLanguage = $language;
    $this->originalLanguageDefault = variable_get('language_default');
73
    $this->originalFileDirectory = variable_get('file_public_path', conf_path() . '/files');
74
75
76
77
78
79
80
81
82
83
84
    $this->originalProfile = drupal_get_profile();
    $clean_url_original = variable_get('clean_url', 0);

    // Unregister the registry.
    // This is required to make sure that the database layer works properly.
    spl_autoload_unregister('drupal_autoload_class');
    spl_autoload_unregister('drupal_autoload_interface');

    // Create test directories ahead of installation so fatal errors and debug
    // information can be logged during installation process.
    // Use mock files directories with the same prefix as the database.
85
    $public_files_directory  = $this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10);
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
    $private_files_directory = $public_files_directory . '/private';
    $temp_files_directory    = $private_files_directory . '/temp';

    // Create the directories.
    file_prepare_directory($public_files_directory, FILE_CREATE_DIRECTORY | FILE_MODIFY_PERMISSIONS);
    file_prepare_directory($private_files_directory, FILE_CREATE_DIRECTORY);
    file_prepare_directory($temp_files_directory, FILE_CREATE_DIRECTORY);
    $this->generatedTestFiles = FALSE;

    // Log fatal errors.
    ini_set('log_errors', 1);
    ini_set('error_log', $public_files_directory . '/error.log');

    // Reset all statics and variables to perform tests in a clean environment.
    $conf = array();

    // Load the database from the portable PHP dump.
103
    // The files can be gzipped.
104
    foreach ($this->databaseDumpFiles as $file) {
105
106
107
      if (substr($file, -3) == '.gz') {
        $file = "compress.zlib://$file";
      }
108
109
      require $file;
    }
110
111
112
113
114
115
116
117
118
119
120
121
122

    // Set path variables.
    $this->variable_set('file_public_path', $public_files_directory);
    $this->variable_set('file_private_path', $private_files_directory);
    $this->variable_set('file_temporary_path', $temp_files_directory);

    $this->pass('Finished loading the dump.');

    // Load user 1.
    $this->originalUser = $user;
    drupal_save_session(FALSE);
    $user = db_query('SELECT * FROM {users} WHERE uid = :uid', array(':uid' => 1))->fetchObject();

123
    // Generate and set a D6-compatible session cookie.
124
125
    $this->curlInitialize();
    $sid = drupal_hash_base64(uniqid(mt_rand(), TRUE) . drupal_random_bytes(55));
126
    curl_setopt($this->curlHandle, CURLOPT_COOKIE, rawurlencode(session_name()) . '=' . rawurlencode($sid));
127
128
129
130

    // Force our way into the session of the child site.
    drupal_save_session(TRUE);
    _drupal_session_write($sid, '');
131
    // Remove the temporarily added ssid column.
132
133
134
135
136
137
138
139
140
141
142
143
144
    drupal_save_session(FALSE);

    // Restore necessary variables.
    $this->variable_set('clean_url', $clean_url_original);
    $this->variable_set('site_mail', 'simpletest@example.com');

    drupal_set_time_limit($this->timeLimit);
  }

  /**
   * Override of DrupalWebTestCase::tearDown() specialized for upgrade testing.
   */
  protected function tearDown() {
145
    global $user, $language;
146

147
148
149
150
151
    if (!empty($this->missing_zlib_requirement)) {
      parent::tearDown();
      return;
    }

152
153
    // In case a fatal error occured that was not in the test process read the
    // log to pick up any fatal errors.
154
155
156
157
158
159
160
161
162
163
164
165
166
    simpletest_log_read($this->testId, $this->databasePrefix, get_class($this), TRUE);

    // Delete temporary files directory.
    file_unmanaged_delete_recursive($this->originalFileDirectory . '/simpletest/' . substr($this->databasePrefix, 10));

    // Get back to the original connection.
    Database::removeConnection('default');
    Database::renameConnection('simpletest_original_default', 'default');

    // Remove all prefixed tables.
    $tables = db_find_tables($this->databasePrefix . '%');
    foreach ($tables as $table) {
      db_drop_table($table);
167
    }
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

    // Return the user to the original one.
    $user = $this->originalUser;
    drupal_save_session(TRUE);

    // Ensure that internal logged in variable and cURL options are reset.
    $this->loggedInUser = FALSE;
    $this->additionalCurlOptions = array();

    // Reload module list and implementations to ensure that test module hooks
    // aren't called after tests.
    module_list(TRUE);
    module_implements('', FALSE, TRUE);

    // Reset the Field API.
    field_cache_clear();

    // Rebuild caches.
    parent::refreshVariables();

    // Reset language.
    $language = $this->originalLanguage;
    if ($this->originalLanguageDefault) {
      $GLOBALS['conf']['language_default'] = $this->originalLanguageDefault;
    }

    // Close the CURL handler.
    $this->curlClose();
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
  }

  /**
   * Specialized variable_set() that works even if the child site is not upgraded.
   *
   * @param $name
   *   The name of the variable to set.
   * @param $value
   *   The value to set. This can be any PHP data type; these functions take care
   *   of serialization as necessary.
   */
  protected function variable_set($name, $value) {
    db_delete('variable')
      ->condition('name', $name)
      ->execute();
    db_insert('variable')
      ->fields(array(
        'name' => $name,
        'value' => serialize($value),
      ))
      ->execute();

    try {
219
220
      cache()->delete('variables');
      cache('bootstrap')->delete('variables');
221
222
223
    }
    // Since cache_bootstrap won't exist in a Drupal 6 site, ignore the
    // exception if the above fails.
224
    catch (Exception $e) {}
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
  }

  /**
   * Specialized refreshVariables().
   */
  protected function refreshVariables() {
    // No operation if the child has not been upgraded yet.
    if (!$this->upgradedSite) {
      return parent::refreshVariables();
    }
  }

  /**
   * Perform the upgrade.
   *
   * @param $register_errors
   *   Register the errors during the upgrade process as failures.
   * @return
   *   TRUE if the upgrade succeeded, FALSE otherwise.
   */
  protected function performUpgrade($register_errors = TRUE) {
    $update_url = $GLOBALS['base_url'] . '/update.php';

248
249
250
251
252
    if (!empty($this->missing_zlib_requirement)) {
      $this->fail(t('Missing zlib requirement for upgrade tests.'));
      return FALSE;
    }

253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
    // Load the first update screen.
    $this->drupalGet($update_url, array('external' => TRUE));
    if (!$this->assertResponse(200)) {
      return FALSE;
    }

    // Continue.
    $this->drupalPost(NULL, array(), t('Continue'));
    if (!$this->assertResponse(200)) {
      return FALSE;
    }

    // Go!
    $this->drupalPost(NULL, array(), t('Apply pending updates'));
    if (!$this->assertResponse(200)) {
      return FALSE;
    }

    // Check for errors during the update process.
    foreach ($this->xpath('//li[@class=:class]', array(':class' => 'failure')) as $element) {
      $message = strip_tags($element->asXML());
      $this->upgradeErrors[] = $message;
      if ($register_errors) {
        $this->fail($message);
      }
    }

    if (!empty($this->upgradeErrors)) {
      // Upgrade failed, the installation might be in an inconsistent state,
      // don't process.
      return FALSE;
    }

    // Check if there still are pending updates.
    $this->drupalGet($update_url, array('external' => TRUE));
    $this->drupalPost(NULL, array(), t('Continue'));
289
    if (!$this->assertText(t('No pending updates.'), t('No pending updates at the end of the update process.'))) {
290
291
292
293
294
295
296
      return FALSE;
    }

    // Upgrade succeed, rebuild the environment so that we can call the API
    // of the child site directly from this request.
    $this->upgradedSite = TRUE;

297
298
299
300
301
302
303
304
    // Reload module list. For modules that are enabled in the test database,
    // but not on the test client, we need to load the code here.
    $new_modules = array_diff(module_list(TRUE), $this->loadedModules);
    foreach ($new_modules as $module) {
      drupal_load('module', $module);
    }

    // Reload hook implementations
305
306
307
308
309
310
311
312
313
314
315
316
317
    module_implements('', FALSE, TRUE);

    // Rebuild caches.
    drupal_static_reset();
    drupal_flush_all_caches();

    // Reload global $conf array and permissions.
    $this->refreshVariables();
    $this->checkPermissions(array(), TRUE);

    return TRUE;
  }

318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
  /**
   * Force uninstall all modules from a test database, except those listed.
   *
   * @param $modules
   *   The list of modules to keep installed. Required core modules will
   *   always be kept.
   */
  protected function uninstallModulesExcept(array $modules) {
    $required_modules = array('block', 'dblog', 'filter', 'node', 'system', 'update', 'user');

    $modules = array_merge($required_modules, $modules);

    db_delete('system')
      ->condition('type', 'module')
      ->condition('name', $modules, 'NOT IN')
      ->execute();
  }

336
}