field_ui.test 25.9 KB
Newer Older
1 2 3 4
<?php

/**
 * @file
5
 * Tests for field_ui.module.
6 7 8
 */

/**
9
 * Helper class for Field UI test classes.
10 11 12
 */
class FieldUITestCase extends DrupalWebTestCase {

13 14 15 16 17 18 19 20 21
  function setUp() {
    // Since this is a base class for many test cases, support the same
    // flexibility that DrupalWebTestCase::setUp() has for the modules to be
    // passed in as either an array or a variable number of string arguments.
    $modules = func_get_args();
    if (isset($modules[0]) && is_array($modules[0])) {
      $modules = $modules[0];
    }
    $modules[] = 'field_test';
22
    parent::setUp($modules);
23 24

    // Create test user.
25
    $admin_user = $this->drupalCreateUser(array('access content', 'administer content types', 'administer taxonomy'));
26
    $this->drupalLogin($admin_user);
27

28
    // Create content type, with underscores.
29
    $type_name = strtolower($this->randomName(8)) . '_test';
30 31 32 33
    $type = $this->drupalCreateContentType(array('name' => $type_name, 'type' => $type_name));
    $this->type = $type->type;
    // Store a valid URL name, with hyphens instead of underscores.
    $this->hyphen_type = str_replace('_', '-', $this->type);
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
  }

  /**
   * Create a new field through the Field UI.
   *
   * @param $bundle_path
   *   Path of the 'Manage fields' page for the bundle.
   * @param $initial_edit
   *   $edit parameter for drupalPost() on the first step ('Manage fields'
   *   screen).
   * @param $field_edit
   *   $edit parameter for drupalPost() on the second step ('Field settings'
   *   form).
   * @param $instance_edit
   *   $edit parameter for drupalPost() on the third step ('Instance settings'
   *   form).
   */
  function fieldUIAddNewField($bundle_path, $initial_edit, $field_edit = array(), $instance_edit = array()) {
    // Use 'test_field' field type by default.
    $initial_edit += array(
      'fields[_add_new_field][type]' => 'test_field',
      'fields[_add_new_field][widget_type]' => 'test_field_widget',
    );
    $label = $initial_edit['fields[_add_new_field][label]'];
    $field_name = $initial_edit['fields[_add_new_field][field_name]'];

    // First step : 'Add new field' on the 'Manage fields' page.
    $this->drupalPost("$bundle_path/fields",  $initial_edit, t('Save'));
    $this->assertRaw(t('These settings apply to the %label field everywhere it is used.', array('%label' => $label)), t('Field settings page was displayed.'));

    // Second step : 'Field settings' form.
    $this->drupalPost(NULL, $field_edit, t('Save field settings'));
    $this->assertRaw(t('Updated field %label field settings.', array('%label' => $label)), t('Redirected to instance and widget settings page.'));

    // Third step : 'Instance settings' form.
    $this->drupalPost(NULL, $instance_edit, t('Save settings'));
    $this->assertRaw(t('Saved %label configuration.', array('%label' => $label)), t('Redirected to "Manage fields" page.'));

    // Check that the field appears in the overview form.
    $this->assertFieldByXPath('//table[@id="field-overview"]//td[1]', $label, t('Field was created and appears in the overview page.'));
  }

  /**
   * Add an existing field through the Field UI.
   *
   * @param $bundle_path
   *   Path of the 'Manage fields' page for the bundle.
   * @param $initial_edit
   *   $edit parameter for drupalPost() on the first step ('Manage fields'
   *   screen).
   * @param $instance_edit
   *   $edit parameter for drupalPost() on the second step ('Instance settings'
   *   form).
   */
  function fieldUIAddExistingField($bundle_path, $initial_edit, $instance_edit = array()) {
    // Use 'test_field_widget' by default.
    $initial_edit += array(
      'fields[_add_existing_field][widget_type]' => 'test_field_widget',
    );
    $label = $initial_edit['fields[_add_existing_field][label]'];
    $field_name = $initial_edit['fields[_add_existing_field][field_name]'];

    // First step : 'Add existing field' on the 'Manage fields' page.
    $this->drupalPost("$bundle_path/fields", $initial_edit, t('Save'));

    // Second step : 'Instance settings' form.
    $this->drupalPost(NULL, $instance_edit, t('Save settings'));
    $this->assertRaw(t('Saved %label configuration.', array('%label' => $label)), t('Redirected to "Manage fields" page.'));

    // Check that the field appears in the overview form.
    $this->assertFieldByXPath('//table[@id="field-overview"]//td[1]', $label, t('Field was created and appears in the overview page.'));
  }

  /**
   * Delete a field instance through the Field UI.
   *
   * @param $bundle_path
   *   Path of the 'Manage fields' page for the bundle.
   * @param $field_name
   *   The name of the field.
   * @param $label
   *   The label of the field.
   * @param $bundle_label
   *   The label of the bundle.
   */
  function fieldUIDeleteField($bundle_path, $field_name, $label, $bundle_label) {
    // Display confirmation form.
    $this->drupalGet("$bundle_path/fields/$field_name/delete");
    $this->assertRaw(t('Are you sure you want to delete the field %label', array('%label' => $label)), t('Delete confirmation was found.'));

    // Submit confirmation form.
    $this->drupalPost(NULL, array(), t('Delete'));
    $this->assertRaw(t('The field %label has been deleted from the %type content type.', array('%label' => $label, '%type' => $bundle_label)), t('Delete message was found.'));

    // Check that the field does not appear in the overview form.
    $this->assertNoFieldByXPath('//table[@id="field-overview"]//span[@class="label-field"]', $label, t('Field does not appear in the overview page.'));
  }
}

/**
 * Field UI tests for the 'Manage fields' screen.
 */
class FieldUIManageFieldsTestCase extends FieldUITestCase {
  public static function getInfo() {
    return array(
      'name' => 'Manage fields',
      'description' => 'Test the Field UI "Manage fields" screen.',
      'group' => 'Field UI',
    );
  }

  function setUp() {
    parent::setUp();
147 148 149

    // Create random field name.
    $this->field_label = $this->randomName(8);
150
    $this->field_name_input =  strtolower($this->randomName(8));
151
    $this->field_name = 'field_'. $this->field_name_input;
152 153
  }

154 155 156 157 158 159
  /**
   * Main entry point for the field CRUD tests.
   *
   * In order to act on the same fields, and not create the fields over and over
   * again the following tests create, update and delete the same fields.
   */
160 161 162 163 164 165 166 167 168 169 170
  function testCRUDFields() {
    $this->manageFieldsPage();
    $this->createField();
    $this->updateField();
    $this->addExistingField();
  }

  /**
   * Test the manage fields page.
   */
  function manageFieldsPage() {
171
    $this->drupalGet('admin/structure/types/manage/' . $this->hyphen_type . '/fields');
172 173 174 175 176 177 178 179 180 181
    // Check all table columns.
    $table_headers = array(
      t('Label'),
      t('Name'),
      t('Field'),
      t('Widget'),
      t('Operations'),
    );
    foreach ($table_headers as $table_header) {
      // We check that the label appear in the table headings.
182
      $this->assertRaw($table_header . '</th>', t('%table_header table header was found.', array('%table_header' => $table_header)));
183 184 185 186 187
    }

    // "Add new field" and "Add existing field" aren't a table heading so just
    // test the text.
    foreach (array('Add new field', 'Add existing field') as $element) {
188
      $this->assertText($element, t('"@element" was found.', array('@element' => $element)));
189 190 191 192 193 194 195
    }
  }

  /**
   * Test adding a new field.
   *
   * @todo Assert properties can bet set in the form and read back in $field and
196
   * $instances.
197 198 199
   */
  function createField() {
    // Create a test field.
200
    $edit = array(
201 202
      'fields[_add_new_field][label]' => $this->field_label,
      'fields[_add_new_field][field_name]' => $this->field_name_input,
203
    );
204
    $this->fieldUIAddNewField('admin/structure/types/manage/' . $this->hyphen_type, $edit);
205 206 207 208

    // Assert the field appears in the "add existing field" section for
    // different entity types; e.g. if a field was added in a node entity, it
    // should also appear in the 'taxonomy term' entity.
209 210
    $vocabulary = taxonomy_vocabulary_load(1);
    $this->drupalGet('admin/structure/taxonomy/' . $vocabulary->machine_name . '/fields');
211
    $this->assertTrue($this->xpath('//select[@name="fields[_add_existing_field][field_name]"]//option[@value="' . $this->field_name . '"]'), t('Existing field was found in account settings.'));
212 213 214 215 216 217 218 219 220 221 222
  }

  /**
   * Test editing an existing field.
   */
  function updateField() {
    // Go to the field edit page.
    $this->drupalGet('admin/structure/types/manage/' . $this->hyphen_type . '/fields/' . $this->field_name);

    // Populate the field settings with new settings.
    $string = 'updated dummy test string';
223 224 225 226 227
    $edit = array(
      'field[settings][test_field_setting]' => $string,
      'instance[settings][test_instance_setting]' => $string,
      'instance[widget][settings][test_widget_setting]' => $string,
    );
228 229
    $this->drupalPost(NULL, $edit, t('Save settings'));

230
    // Assert the field settings are correct.
231 232 233
    $this->assertFieldSettings($this->type, $this->field_name, $string);

    // Assert redirection back to the "manage fields" page.
234
    $this->assertText(t('Saved @label configuration.', array('@label' => $this->field_label)), t('Redirected to "Manage fields" page.'));
235 236 237 238 239 240 241
  }

  /**
   * Test adding an existing field in another content type.
   */
  function addExistingField() {
    // Check "Add existing field" appears.
242
    $this->drupalGet('admin/structure/types/manage/page/fields');
243
    $this->assertRaw(t('Add existing field'), t('"Add existing field" was found.'));
244

245 246
    // Check that the list of options respects entity type restrictions on
    // fields. The 'comment' field is restricted to the 'comment' entity type
247
    // and should not appear in the list.
248
    $this->assertFalse($this->xpath('//select[@id="edit-add-existing-field-field-name"]//option[@value="comment"]'), t('The list of options respects entity type restrictions.'));
249

250
    // Add a new field based on an existing field.
251
    $edit = array(
252 253
      'fields[_add_existing_field][label]' => $this->field_label . '_2',
      'fields[_add_existing_field][field_name]' => $this->field_name,
254
    );
255
    $this->fieldUIAddExistingField("admin/structure/types/manage/page", $edit);
256 257 258 259 260 261 262 263 264 265 266
  }

  /**
   * Assert the field settings.
   *
   * @param $bundle
   *   The bundle name for the instance.
   * @param $field_name
   *   The field name for the instance.
   * @param $string
   *   The settings text.
267
   * @param $entity_type
268
   *   The entity type for the instance.
269
   */
270
  function assertFieldSettings($bundle, $field_name, $string = 'dummy test string', $entity_type = 'node') {
271 272 273 274
    // Reset the fields info.
    _field_info_collate_fields(TRUE);
    // Assert field settings.
    $field = field_info_field($field_name);
275
    $this->assertTrue($field['settings']['test_field_setting'] == $string, t('Field settings were found.'));
276 277

    // Assert instance and widget settings.
278
    $instance = field_info_instance($entity_type, $field_name, $bundle);
279 280
    $this->assertTrue($instance['settings']['test_instance_setting'] == $string, t('Field instance settings were found.'));
    $this->assertTrue($instance['widget']['settings']['test_widget_setting'] == $string, t('Field widget settings were found.'));
281
  }
282 283 284 285 286 287 288 289 290 291 292 293 294 295

  /**
   * Tests that default value is correctly validated and saved.
   */
  function testDefaultValue() {
    // Create a test field and instance.
    $field_name = 'test';
    $field = array(
      'field_name' => $field_name,
      'type' => 'test_field'
    );
    field_create_field($field);
    $instance = array(
      'field_name' => $field_name,
296
      'entity_type' => 'node',
297 298 299 300
      'bundle' => $this->type,
    );
    field_create_instance($instance);

301
    $langcode = LANGUAGE_NONE;
302
    $admin_path = 'admin/structure/types/manage/' . $this->hyphen_type . '/fields/' . $field_name;
303 304
    $element_id = "edit-$field_name-$langcode-0-value";
    $element_name = "{$field_name}[$langcode][0][value]";
305
    $this->drupalGet($admin_path);
306
    $this->assertFieldById($element_id, '', t('The default value widget was empty.'));
307 308 309 310

    // Check that invalid default values are rejected.
    $edit = array($element_name => '-1');
    $this->drupalPost($admin_path, $edit, t('Save settings'));
311
    $this->assertText("$field_name does not accept the value -1", t('Form vaildation failed.'));
312 313 314 315

    // Check that the default value is saved.
    $edit = array($element_name => '1');
    $this->drupalPost($admin_path, $edit, t('Save settings'));
316
    $this->assertText("Saved $field_name configuration", t('The form was successfully submitted.'));
317
    $instance = field_info_instance('node', $field_name, $this->type);
318
    $this->assertEqual($instance['default_value'], array(array('value' => 1)), t('The default value was correctly saved.'));
319 320 321

    // Check that the default value shows up in the form
    $this->drupalGet($admin_path);
322
    $this->assertFieldById($element_id, '1', t('The default value widget was displayed with the correct value.'));
323 324 325 326

    // Check that the default value can be emptied.
    $edit = array($element_name => '');
    $this->drupalPost(NULL, $edit, t('Save settings'));
327
    $this->assertText("Saved $field_name configuration", t('The form was successfully submitted.'));
328 329
    field_info_cache_clear();
    $instance = field_info_instance('node', $field_name, $this->type);
330
    $this->assertEqual($instance['default_value'], NULL, t('The default value was correctly saved.'));
331
  }
332 333 334 335 336 337 338 339

  /**
   * Tests that deletion removes fields and instances as expected.
   */
  function testDeleteField() {
    // Create a new field.
    $bundle_path1 = 'admin/structure/types/manage/' . $this->hyphen_type;
    $edit1 = array(
340 341
      'fields[_add_new_field][label]' => $this->field_label,
      'fields[_add_new_field][field_name]' => $this->field_name,
342 343 344 345
    );
    $this->fieldUIAddNewField($bundle_path1, $edit1);

    // Create an additional node type.
346
    $type_name2 = strtolower($this->randomName(8)) . '_test';
347 348 349 350 351 352 353
    $type2 = $this->drupalCreateContentType(array('name' => $type_name2, 'type' => $type_name2));
    $type_name2 = $type2->type;
    $hyphen_type2 = str_replace('_', '-', $type_name2);

    // Add an instance to the second node type.
    $bundle_path2 = 'admin/structure/types/manage/' . $hyphen_type2;
    $edit2 = array(
354 355
      'fields[_add_existing_field][label]' => $this->field_label,
      'fields[_add_existing_field][field_name]' => $this->field_name,
356 357 358 359 360 361 362 363 364
    );
    $this->fieldUIAddExistingField($bundle_path2, $edit2);

    // Delete the first instance.
    $this->fieldUIDeleteField($bundle_path1, $this->field_name, $this->field_label, $this->type);

    // Reset the fields info.
    _field_info_collate_fields(TRUE);
    // Check that the field instance was deleted.
365
    $this->assertNull(field_info_instance('node', $this->field_name, $this->type), t('Field instance was deleted.'));
366
    // Check that the field was not deleted
367
    $this->assertNotNull(field_info_field($this->field_name), t('Field was not deleted.'));
368 369 370 371 372 373 374

    // Delete the second instance.
    $this->fieldUIDeleteField($bundle_path2, $this->field_name, $this->field_label, $type_name2);

    // Reset the fields info.
    _field_info_collate_fields(TRUE);
    // Check that the field instance was deleted.
375
    $this->assertNull(field_info_instance('node', $this->field_name, $type_name2), t('Field instance was deleted.'));
376
    // Check that the field was deleted too.
377
    $this->assertNull(field_info_field($this->field_name), t('Field was deleted.'));
378 379
  }

380 381 382 383 384 385 386 387
  /**
   * Test that Field UI respects the 'no_ui' option in hook_field_info().
   */
  function testHiddenFields() {
    $bundle_path = 'admin/structure/types/manage/' . $this->hyphen_type . '/fields/';

    // Check that the field type is not available in the 'add new field' row.
    $this->drupalGet($bundle_path);
388
    $this->assertFalse($this->xpath('//select[@id="edit-add-new-field-type"]//option[@value="hidden_test_field"]'), t("The 'add new field' select respects field types 'no_ui' property."));
389 390 391 392 393 394 395 396 397

    // Create a field and an instance programmatically.
    $field_name = 'hidden_test_field';
    field_create_field(array('field_name' => $field_name, 'type' => $field_name));
    $instance = array(
      'field_name' => $field_name,
      'bundle' => $this->type,
      'entity_type' => 'node',
      'label' => t('Hidden field'),
398
      'widget' => array('type' => 'test_field_widget'),
399 400
    );
    field_create_instance($instance);
401
    $this->assertTrue(field_read_instance('node', $field_name, $this->type), t('An instance of the field %field was created programmatically.', array('%field' => $field_name)));
402 403 404 405

    // Check that the newly added instance appears on the 'Manage Fields'
    // screen.
    $this->drupalGet($bundle_path);
406
    $this->assertFieldByXPath('//table[@id="field-overview"]//td[1]', $instance['label'], t('Field was created and appears in the overview page.'));
407 408 409 410 411

    // Check that the instance does not appear in the 'add existing field' row
    // on other bundles.
    $bundle_path = 'admin/structure/types/manage/article/fields/';
    $this->drupalGet($bundle_path);
412
    $this->assertFalse($this->xpath('//select[@id="edit-add-existing-field-field-name"]//option[@value=:field_name]', array(':field_name' => $field_name)), t("The 'add existing field' select respects field types 'no_ui' property."));
413
  }
414
}
415

416 417 418 419 420 421 422 423 424
/**
 * Field UI tests for the 'Manage display' screens.
 */
class FieldUIManageDisplayTestCase extends FieldUITestCase {
  public static function getInfo() {
    return array(
      'name' => 'Manage display',
      'description' => 'Test the Field UI "Manage display" screens.',
      'group' => 'Field UI',
425 426 427
    );
  }

428 429
  function setUp() {
    parent::setUp(array('search'));
430 431 432
  }

  /**
433
   * Test formatter formatter settings.
434
   */
435 436 437
  function testFormatterUI() {
    $manage_fields = 'admin/structure/types/manage/' . $this->hyphen_type;
    $manage_display = $manage_fields . '/display';
438

439 440 441 442 443 444
    // Create a field, and a node with some data for the field.
    $edit = array(
      'fields[_add_new_field][label]' => 'Test field',
      'fields[_add_new_field][field_name]' => 'field_test',
    );
    $this->fieldUIAddNewField($manage_fields, $edit);
445

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
    // Clear the test-side cache and get the saved field instance.
    field_info_cache_clear();
    $instance = field_info_instance('node', 'field_test', $this->type);
    $format = $instance['display']['default']['type'];
    $default_settings = field_info_formatter_settings($format);
    $setting_name = key($default_settings);
    $setting_value = $instance['display']['default']['settings'][$setting_name];

    // Display the "Manage display" screen and check that the expected formatter is
    // selected.
    $this->drupalGet($manage_display);
    $this->assertFieldByName('fields[field_test][type]', $format, t('The expected formatter is selected.'));
    $this->assertText("$setting_name: $setting_value", t('The expected summary is displayed.'));

    // Change the formatter and check that the summary is updated.
    $edit = array('fields[field_test][type]' => 'field_test_multiple', 'refresh_rows' => 'field_test');
    $this->drupalPostAJAX(NULL, $edit, array('op' => t('Refresh')));
    $format = 'field_test_multiple';
    $default_settings = field_info_formatter_settings($format);
    $setting_name = key($default_settings);
    $setting_value = $default_settings[$setting_name];
    $this->assertFieldByName('fields[field_test][type]', $format, t('The expected formatter is selected.'));
    $this->assertText("$setting_name: $setting_value", t('The expected summary is displayed.'));

    // Submit the form and check that the instance is updated.
    $this->drupalPost(NULL, array(), t('Save'));
    field_info_cache_clear();
    $instance = field_info_instance('node', 'field_test', $this->type);
    $current_format = $instance['display']['default']['type'];
    $current_setting_value = $instance['display']['default']['settings'][$setting_name];
    $this->assertEqual($current_format, $format, t('The formatter was updated.'));
    $this->assertEqual($current_setting_value, $setting_value, t('The setting was updated.'));
478
  }
479 480 481 482 483 484 485 486 487 488 489

  /**
   * Test switching view modes to use custom or 'default' settings'.
   */
  function testViewModeCustom() {
    // Create a field, and a node with some data for the field.
    $edit = array(
      'fields[_add_new_field][label]' => 'Test field',
      'fields[_add_new_field][field_name]' => 'field_test',
    );
    $this->fieldUIAddNewField('admin/structure/types/manage/' . $this->hyphen_type, $edit);
490 491 492 493
    // For this test, use a formatter setting value that is an integer unlikely
    // to appear in a rendered node other than as part of the field being tested
    // (for example, unlikely to be part of the "Submitted by ... on ..." line).
    $value = 12345;
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    $settings = array(
      'type' => $this->type,
      'field_test' => array(LANGUAGE_NONE => array(array('value' => $value))),
    );
    $node = $this->drupalCreateNode($settings);

    // Gather expected output values with the various formatters.
    $formatters = field_info_formatter_types();
    $output = array(
      'field_test_default' => $formatters['field_test_default']['settings']['test_formatter_setting'] . '|' . $value,
      'field_test_with_prepare_view' => $formatters['field_test_with_prepare_view']['settings']['test_formatter_setting_additional'] . '|' . $value. '|' . ($value + 1),
    );

    // Check that the field is displayed with the default formatter in 'rss'
    // mode (uses 'default'), and hidden in 'teaser' mode (uses custom settings).
    $this->assertNodeViewText($node, 'rss', $output['field_test_default'], t("The field is displayed as expected in view modes that use 'default' settings."));
    $this->assertNodeViewNoText($node, 'teaser', $value, t("The field is hidden in view modes that use custom settings."));

    // Change fomatter for 'default' mode, check that the field is displayed
    // accordingly in 'rss' mode.
    $edit = array(
      'fields[field_test][type]' => 'field_test_with_prepare_view',
    );
    $this->drupalPost('admin/structure/types/manage/' . $this->hyphen_type . '/display', $edit, t('Save'));
    $this->assertNodeViewText($node, 'rss', $output['field_test_with_prepare_view'], t("The field is displayed as expected in view modes that use 'default' settings."));

    // Specialize the 'rss' mode, check that the field is displayed the same.
    $edit = array(
      "view_modes_custom[rss]" => TRUE,
    );
    $this->drupalPost('admin/structure/types/manage/' . $this->hyphen_type . '/display', $edit, t('Save'));
    $this->assertNodeViewText($node, 'rss', $output['field_test_with_prepare_view'], t("The field is displayed as expected in newly specialized 'rss' mode."));

    // Set the field to 'hidden' in the view mode, check that the field is
    // hidden.
    $edit = array(
      'fields[field_test][type]' => 'hidden',
    );
    $this->drupalPost('admin/structure/types/manage/' . $this->hyphen_type . '/display/rss', $edit, t('Save'));
    $this->assertNodeViewNoText($node, 'rss', $value, t("The field is hidden in 'rss' mode."));

    // Set the view mode back to 'default', check that the field is displayed
    // accordingly.
    $edit = array(
      "view_modes_custom[rss]" => FALSE,
    );
    $this->drupalPost('admin/structure/types/manage/' . $this->hyphen_type . '/display', $edit, t('Save'));
    $this->assertNodeViewText($node, 'rss', $output['field_test_with_prepare_view'], t("The field is displayed as expected when 'rss' mode is set back to 'default' settings."));

    // Specialize the view mode again.
    $edit = array(
      "view_modes_custom[rss]" => TRUE,
    );
    $this->drupalPost('admin/structure/types/manage/' . $this->hyphen_type . '/display', $edit, t('Save'));
    // Check that the previous settings for the view mode have been kept.
    $this->assertNodeViewNoText($node, 'rss', $value, t("The previous settings are kept when 'rss' mode is specialized again."));
  }

  /**
   * Pass if the text is found in the rendered node in a given view mode.
   *
   * @param $node
   *   The node.
   * @param $view_mode
   *   The view mode in which the node should be displayed.
   * @param $text
   *   Plain text to look for.
   * @param $message
   *   Message to display.
   *
   * @return
   *   TRUE on pass, FALSE on fail.
   */
  function assertNodeViewText($node, $view_mode, $text, $message) {
    return $this->assertNodeViewTextHelper($node, $view_mode, $text, $message, FALSE);
  }

  /**
   * Pass if the text is node found in the rendered node in a given view mode.
   *
   * @param $node
   *   The node.
   * @param $view_mode
   *   The view mode in which the node should be displayed.
   * @param $text
   *   Plain text to look for.
   * @param $message
   *   Message to display.
   * @return
   *   TRUE on pass, FALSE on fail.
   */
  function assertNodeViewNoText($node, $view_mode, $text, $message) {
    return $this->assertNodeViewTextHelper($node, $view_mode, $text, $message, TRUE);
  }

  /**
   * Helper for assertNodeViewText and assertNodeViewNoText.
   *
   * @param $node
   *   The node.
   * @param $view_mode
   *   The view mode in which the node should be displayed.
   * @param $text
   *   Plain text to look for.
   * @param $message
   *   Message to display.
   * @param $not_exists
   *   TRUE if this text should not exist, FALSE if it should.
   *
   * @return
   *   TRUE on pass, FALSE on fail.
   */
  function assertNodeViewTextHelper($node, $view_mode, $text, $message, $not_exists) {
    // Make sure caches on the tester side are refreshed after changes
    // submitted on the tested side.
    field_info_cache_clear();

    // Save current content so that we can restore it when we're done.
    $old_content = $this->drupalGetContent();

    // Render a cloned node, so that we do not alter the original.
    $clone = clone $node;
616 617
    $element = node_view($clone, $view_mode);
    $output = drupal_render($element);
618 619 620 621 622 623 624 625 626 627 628 629
    $this->verbose(t('Rendered node - view mode: @view_mode', array('@view_mode' => $view_mode)) . '<hr />'. $output);

    // Assign content so that DrupalWebTestCase functions can be used.
    $this->drupalSetContent($output);
    $method = ($not_exists ? 'assertNoText' : 'assertText');
    $return = $this->{$method}((string) $text, $message);

    // Restore previous content.
    $this->drupalSetContent($old_content);

    return $return;
  }
630
}