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

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

8
use Drupal\node\Node;
9
use Drupal\simpletest\WebTestBase;
10

11
/**
12
 * Provides common functionality for the Field UI test classes.
13
 */
14
class FieldUITestCase extends WebTestBase {
15

16 17
  function setUp() {
    // Since this is a base class for many test cases, support the same
18 19 20
    // flexibility that Drupal\simpletest\WebTestBase::setUp() has for the
    // modules to be passed in as either an array or a variable number of string
    // arguments.
21 22 23 24
    $modules = func_get_args();
    if (isset($modules[0]) && is_array($modules[0])) {
      $modules = $modules[0];
    }
25
    $modules[] = 'node';
26
    $modules[] = 'field_ui';
27
    $modules[] = 'field_test';
28
    $modules[] = 'taxonomy';
29
    parent::setUp($modules);
30 31

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

35
    // Create content type, with underscores.
36
    $type_name = strtolower($this->randomName(8)) . '_test';
37 38
    $type = $this->drupalCreateContentType(array('name' => $type_name, 'type' => $type_name));
    $this->type = $type->type;
39 40 41
  }

  /**
42
   * Creates a new field through the Field UI.
43 44
   *
   * @param $bundle_path
45
   *   Admin path of the bundle that the new field is to be attached to.
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
   * @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.'));
  }

  /**
82
   * Adds an existing field through the Field UI.
83 84
   *
   * @param $bundle_path
85
   *   Admin path of the bundle that the field is to be attached to.
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
   * @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.'));
  }

  /**
113
   * Deletes a field instance through the Field UI.
114 115
   *
   * @param $bundle_path
116
   *   Admin path of the bundle that the field instance is to be deleted from.
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
   * @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.'));
  }
}

/**
139
 * Tests the functionality of the 'Manage fields' screen.
140 141 142 143 144 145 146 147 148 149 150 151
 */
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();
152 153 154

    // Create random field name.
    $this->field_label = $this->randomName(8);
155
    $this->field_name_input =  strtolower($this->randomName(8));
156
    $this->field_name = 'field_'. $this->field_name_input;
157 158 159 160 161 162

    // Create Basic page and Article node types.
    $this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
    $this->drupalCreateContentType(array('type' => 'article', 'name' => 'Article'));

    // Create a vocabulary named "Tags".
163
    $vocabulary = entity_create('taxonomy_vocabulary', array(
164 165
      'name' => 'Tags',
      'machine_name' => 'tags',
166
      'langcode' => LANGUAGE_NOT_SPECIFIED,
167
    ));
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
    taxonomy_vocabulary_save($vocabulary);

    $field = array(
      'field_name' => 'field_' . $vocabulary->machine_name,
      'type' => 'taxonomy_term_reference',
    );
    field_create_field($field);

    $instance = array(
      'field_name' => 'field_' . $vocabulary->machine_name,
      'entity_type' => 'node',
      'label' => 'Tags',
      'bundle' => 'article',
    );
    field_create_instance($instance);
183 184
  }

185
  /**
186
   * Runs the field CRUD tests.
187 188 189 190
   *
   * 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.
   */
191 192 193 194 195 196 197 198
  function testCRUDFields() {
    $this->manageFieldsPage();
    $this->createField();
    $this->updateField();
    $this->addExistingField();
  }

  /**
199
   * Tests the manage fields page.
200 201
   */
  function manageFieldsPage() {
202
    $this->drupalGet('admin/structure/types/manage/' . $this->type . '/fields');
203 204 205
    // Check all table columns.
    $table_headers = array(
      t('Label'),
206
      t('Machine name'),
207 208 209 210 211 212
      t('Field'),
      t('Widget'),
      t('Operations'),
    );
    foreach ($table_headers as $table_header) {
      // We check that the label appear in the table headings.
213
      $this->assertRaw($table_header . '</th>', t('%table_header table header was found.', array('%table_header' => $table_header)));
214 215 216 217 218
    }

    // "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) {
219
      $this->assertText($element, t('"@element" was found.', array('@element' => $element)));
220 221 222 223
    }
  }

  /**
224
   * Tests adding a new field.
225 226
   *
   * @todo Assert properties can bet set in the form and read back in $field and
227
   * $instances.
228 229 230
   */
  function createField() {
    // Create a test field.
231
    $edit = array(
232 233
      'fields[_add_new_field][label]' => $this->field_label,
      'fields[_add_new_field][field_name]' => $this->field_name_input,
234
    );
235
    $this->fieldUIAddNewField('admin/structure/types/manage/' . $this->type, $edit);
236 237 238 239

    // 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.
240 241
    $vocabulary = taxonomy_vocabulary_load(1);
    $this->drupalGet('admin/structure/taxonomy/' . $vocabulary->machine_name . '/fields');
242
    $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.'));
243 244 245
  }

  /**
246
   * Tests editing an existing field.
247 248 249
   */
  function updateField() {
    // Go to the field edit page.
250
    $this->drupalGet('admin/structure/types/manage/' . $this->type . '/fields/' . $this->field_name);
251 252 253

    // Populate the field settings with new settings.
    $string = 'updated dummy test string';
254 255 256 257 258
    $edit = array(
      'field[settings][test_field_setting]' => $string,
      'instance[settings][test_instance_setting]' => $string,
      'instance[widget][settings][test_widget_setting]' => $string,
    );
259 260
    $this->drupalPost(NULL, $edit, t('Save settings'));

261
    // Assert the field settings are correct.
262 263 264
    $this->assertFieldSettings($this->type, $this->field_name, $string);

    // Assert redirection back to the "manage fields" page.
265
    $this->assertText(t('Saved @label configuration.', array('@label' => $this->field_label)), t('Redirected to "Manage fields" page.'));
266 267 268
  }

  /**
269
   * Tests adding an existing field in another content type.
270 271 272
   */
  function addExistingField() {
    // Check "Add existing field" appears.
273
    $this->drupalGet('admin/structure/types/manage/page/fields');
274
    $this->assertRaw(t('Add existing field'), t('"Add existing field" was found.'));
275

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

281
    // Add a new field based on an existing field.
282
    $edit = array(
283 284
      'fields[_add_existing_field][label]' => $this->field_label . '_2',
      'fields[_add_existing_field][field_name]' => $this->field_name,
285
    );
286
    $this->fieldUIAddExistingField("admin/structure/types/manage/page", $edit);
287 288 289
  }

  /**
290
   * Asserts field settings are as expected.
291 292 293 294 295 296 297
   *
   * @param $bundle
   *   The bundle name for the instance.
   * @param $field_name
   *   The field name for the instance.
   * @param $string
   *   The settings text.
298
   * @param $entity_type
299
   *   The entity type for the instance.
300
   */
301
  function assertFieldSettings($bundle, $field_name, $string = 'dummy test string', $entity_type = 'node') {
302
    // Reset the fields info.
303
    _field_info_collate_fields_reset();
304 305
    // Assert field settings.
    $field = field_info_field($field_name);
306
    $this->assertTrue($field['settings']['test_field_setting'] == $string, t('Field settings were found.'));
307 308

    // Assert instance and widget settings.
309
    $instance = field_info_instance($entity_type, $field_name, $bundle);
310 311
    $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.'));
312
  }
313 314 315 316 317 318 319 320 321 322 323 324 325 326

  /**
   * 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,
327
      'entity_type' => 'node',
328 329 330 331
      'bundle' => $this->type,
    );
    field_create_instance($instance);

332
    $langcode = LANGUAGE_NOT_SPECIFIED;
333
    $admin_path = 'admin/structure/types/manage/' . $this->type . '/fields/' . $field_name;
334 335
    $element_id = "edit-$field_name-$langcode-0-value";
    $element_name = "{$field_name}[$langcode][0][value]";
336
    $this->drupalGet($admin_path);
337
    $this->assertFieldById($element_id, '', t('The default value widget was empty.'));
338 339 340 341

    // Check that invalid default values are rejected.
    $edit = array($element_name => '-1');
    $this->drupalPost($admin_path, $edit, t('Save settings'));
342
    $this->assertText("$field_name does not accept the value -1", t('Form vaildation failed.'));
343 344 345 346

    // Check that the default value is saved.
    $edit = array($element_name => '1');
    $this->drupalPost($admin_path, $edit, t('Save settings'));
347
    $this->assertText("Saved $field_name configuration", t('The form was successfully submitted.'));
348
    $instance = field_info_instance('node', $field_name, $this->type);
349
    $this->assertEqual($instance['default_value'], array(array('value' => 1)), t('The default value was correctly saved.'));
350 351 352

    // Check that the default value shows up in the form
    $this->drupalGet($admin_path);
353
    $this->assertFieldById($element_id, '1', t('The default value widget was displayed with the correct value.'));
354 355 356 357

    // Check that the default value can be emptied.
    $edit = array($element_name => '');
    $this->drupalPost(NULL, $edit, t('Save settings'));
358
    $this->assertText("Saved $field_name configuration", t('The form was successfully submitted.'));
359 360
    field_info_cache_clear();
    $instance = field_info_instance('node', $field_name, $this->type);
361
    $this->assertEqual($instance['default_value'], NULL, t('The default value was correctly saved.'));
362
  }
363 364 365 366 367 368

  /**
   * Tests that deletion removes fields and instances as expected.
   */
  function testDeleteField() {
    // Create a new field.
369
    $bundle_path1 = 'admin/structure/types/manage/' . $this->type;
370
    $edit1 = array(
371
      'fields[_add_new_field][label]' => $this->field_label,
372
      'fields[_add_new_field][field_name]' => $this->field_name_input,
373 374 375 376
    );
    $this->fieldUIAddNewField($bundle_path1, $edit1);

    // Create an additional node type.
377
    $type_name2 = strtolower($this->randomName(8)) . '_test';
378 379 380 381
    $type2 = $this->drupalCreateContentType(array('name' => $type_name2, 'type' => $type_name2));
    $type_name2 = $type2->type;

    // Add an instance to the second node type.
382
    $bundle_path2 = 'admin/structure/types/manage/' . $type_name2;
383
    $edit2 = array(
384 385
      'fields[_add_existing_field][label]' => $this->field_label,
      'fields[_add_existing_field][field_name]' => $this->field_name,
386 387 388 389 390 391 392
    );
    $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.
393
    _field_info_collate_fields_reset();
394
    // Check that the field instance was deleted.
395
    $this->assertNull(field_info_instance('node', $this->field_name, $this->type), t('Field instance was deleted.'));
396
    // Check that the field was not deleted
397
    $this->assertNotNull(field_info_field($this->field_name), t('Field was not deleted.'));
398 399 400 401 402

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

    // Reset the fields info.
403
    _field_info_collate_fields_reset();
404
    // Check that the field instance was deleted.
405
    $this->assertNull(field_info_instance('node', $this->field_name, $type_name2), t('Field instance was deleted.'));
406
    // Check that the field was deleted too.
407
    $this->assertNull(field_info_field($this->field_name), t('Field was deleted.'));
408 409
  }

410
  /**
411
   * Tests that Field UI respects the 'no_ui' option in hook_field_info().
412 413
   */
  function testHiddenFields() {
414
    $bundle_path = 'admin/structure/types/manage/' . $this->type . '/fields/';
415 416 417

    // Check that the field type is not available in the 'add new field' row.
    $this->drupalGet($bundle_path);
418
    $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."));
419 420 421 422 423 424 425 426 427

    // 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'),
428
      'widget' => array('type' => 'test_field_widget'),
429 430
    );
    field_create_instance($instance);
431
    $this->assertTrue(field_read_instance('node', $field_name, $this->type), t('An instance of the field %field was created programmatically.', array('%field' => $field_name)));
432 433 434 435

    // Check that the newly added instance appears on the 'Manage Fields'
    // screen.
    $this->drupalGet($bundle_path);
436
    $this->assertFieldByXPath('//table[@id="field-overview"]//td[1]', $instance['label'], t('Field was created and appears in the overview page.'));
437 438 439 440 441

    // 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);
442
    $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."));
443
  }
444 445 446 447 448

  /**
   * Tests renaming a bundle.
   */
  function testRenameBundle() {
449
    $type2 = strtolower($this->randomName(8)) . '_test';
450 451 452 453

    $options = array(
      'type' => $type2,
    );
454
    $this->drupalPost('admin/structure/types/manage/' . $this->type, $options, t('Save content type'));
455

456
    $this->drupalGet('admin/structure/types/manage/' . $type2 . '/fields');
457
  }
458 459 460 461 462 463 464 465 466 467 468 469 470

  /**
   * Tests that a duplicate field name is caught by validation.
   */
  function testDuplicateFieldName() {
    // field_tags already exists, so we're expecting an error when trying to
    // create a new field with the same name.
    $edit = array(
      'fields[_add_new_field][field_name]' => 'tags',
      'fields[_add_new_field][label]' => $this->randomName(),
      'fields[_add_new_field][type]' => 'taxonomy_term_reference',
      'fields[_add_new_field][widget_type]' => 'options_select',
    );
471
    $url = 'admin/structure/types/manage/' . $this->type . '/fields';
472 473 474 475 476
    $this->drupalPost($url, $edit, t('Save'));

    $this->assertText(t('The machine-readable name is already in use. It must be unique.'));
    $this->assertUrl($url, array(), 'Stayed on the same page.');
  }
477
}
478

479
/**
480
 * Tests the functionality of the 'Manage display' screens.
481 482 483 484 485 486 487
 */
class FieldUIManageDisplayTestCase extends FieldUITestCase {
  public static function getInfo() {
    return array(
      'name' => 'Manage display',
      'description' => 'Test the Field UI "Manage display" screens.',
      'group' => 'Field UI',
488 489 490
    );
  }

491 492
  function setUp() {
    parent::setUp(array('search'));
493 494 495
  }

  /**
496
   * Tests formatter settings.
497
   */
498
  function testFormatterUI() {
499
    $manage_fields = 'admin/structure/types/manage/' . $this->type;
500
    $manage_display = $manage_fields . '/display';
501

502 503 504
    // Create a field, and a node with some data for the field.
    $edit = array(
      'fields[_add_new_field][label]' => 'Test field',
505
      'fields[_add_new_field][field_name]' => 'test',
506 507
    );
    $this->fieldUIAddNewField($manage_fields, $edit);
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
    // 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.'));
541
  }
542 543

  /**
544
   * Tests switching view modes to use custom or 'default' settings'.
545 546 547 548 549
   */
  function testViewModeCustom() {
    // Create a field, and a node with some data for the field.
    $edit = array(
      'fields[_add_new_field][label]' => 'Test field',
550
      'fields[_add_new_field][field_name]' => 'test',
551
    );
552
    $this->fieldUIAddNewField('admin/structure/types/manage/' . $this->type, $edit);
553 554 555 556
    // 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;
557 558
    $settings = array(
      'type' => $this->type,
559
      'field_test' => array(LANGUAGE_NOT_SPECIFIED => array(array('value' => $value))),
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
    );
    $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',
    );
580
    $this->drupalPost('admin/structure/types/manage/' . $this->type . '/display', $edit, t('Save'));
581 582 583 584 585 586
    $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,
    );
587
    $this->drupalPost('admin/structure/types/manage/' . $this->type . '/display', $edit, t('Save'));
588 589 590 591 592 593 594
    $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',
    );
595
    $this->drupalPost('admin/structure/types/manage/' . $this->type . '/display/rss', $edit, t('Save'));
596 597 598 599 600 601 602
    $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,
    );
603
    $this->drupalPost('admin/structure/types/manage/' . $this->type . '/display', $edit, t('Save'));
604 605 606 607 608 609
    $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,
    );
610
    $this->drupalPost('admin/structure/types/manage/' . $this->type . '/display', $edit, t('Save'));
611 612 613 614 615
    // 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."));
  }

  /**
616
   * Asserts that a string is found in the rendered node in a view mode.
617
   *
618
   * @param Node $node
619 620 621 622 623 624 625 626 627 628 629
   *   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.
   */
630
  function assertNodeViewText(Node $node, $view_mode, $text, $message) {
631 632 633 634
    return $this->assertNodeViewTextHelper($node, $view_mode, $text, $message, FALSE);
  }

  /**
635
   * Asserts that a string is not found in the rendered node in a view mode.
636
   *
637
   * @param Node $node
638 639 640 641 642 643 644 645 646 647
   *   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.
   */
648
  function assertNodeViewNoText(Node $node, $view_mode, $text, $message) {
649 650 651 652
    return $this->assertNodeViewTextHelper($node, $view_mode, $text, $message, TRUE);
  }

  /**
653 654 655 656
   * Asserts that a string is (not) found in the rendered nodein a view mode.
   *
   * This helper function is used by assertNodeViewText() and
   * assertNodeViewNoText().
657
   *
658
   * @param Node $node
659 660 661 662 663 664 665 666 667 668 669 670 671
   *   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.
   */
672
  function assertNodeViewTextHelper(Node $node, $view_mode, $text, $message, $not_exists) {
673 674 675 676 677 678 679 680 681
    // 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;
682 683
    $element = node_view($clone, $view_mode);
    $output = drupal_render($element);
684 685
    $this->verbose(t('Rendered node - view mode: @view_mode', array('@view_mode' => $view_mode)) . '<hr />'. $output);

686
    // Assign content so that WebTestBase functions can be used.
687 688 689 690 691 692 693 694 695
    $this->drupalSetContent($output);
    $method = ($not_exists ? 'assertNoText' : 'assertText');
    $return = $this->{$method}((string) $text, $message);

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

    return $return;
  }
696
}
697 698 699 700

/**
 * Tests custom widget hooks and callbacks on the field administration pages.
 */
701
class FieldUIAlterTestCase extends WebTestBase {
702 703 704 705 706 707 708 709 710
  public static function getInfo() {
    return array(
      'name' => 'Widget customization',
      'description' => 'Test custom field widget hooks and callbacks on field administration pages.',
      'group' => 'Field UI',
    );
  }

  function setUp() {
711 712 713 714 715
    parent::setUp(array('field_ui', 'field_test', 'text', 'list'));

    // Create Article node type.
    $this->drupalCreateContentType(array('type' => 'page', 'name' => 'Basic page'));
    $this->drupalCreateContentType(array('type' => 'article', 'name' => 'Article'));
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784

    // Create test user.
    $admin_user = $this->drupalCreateUser(array('access content', 'administer content types', 'administer users'));
    $this->drupalLogin($admin_user);
  }

  /**
   * Tests hook_field_widget_properties_alter() on the default field widget.
   *
   * @see field_test_field_widget_properties_alter()
   * @see field_test_field_widget_properties_user_alter()
   * @see field_test_field_widget_form_alter()
   */
  function testDefaultWidgetPropertiesAlter() {
    // Create the alter_test_text field and an instance on article nodes.
    field_create_field(array(
      'field_name' => 'alter_test_text',
      'type' => 'text',
    ));
    field_create_instance(array(
      'field_name' => 'alter_test_text',
      'entity_type' => 'node',
      'bundle' => 'article',
      'widget' => array(
        'type' => 'text_textfield',
        'size' => 60,
      ),
    ));

    // Test that field_test_field_widget_properties_alter() sets the size to
    // 42 and that field_test_field_widget_form_alter() reports the correct
    // size when the form is displayed.
    $this->drupalGet('admin/structure/types/manage/article/fields/alter_test_text');
    $this->assertText('Field size: 42', 'Altered field size is found in hook_field_widget_form_alter().');

    // Create the alter_test_options field.
    field_create_field(array(
      'field_name' => 'alter_test_options',
      'type' => 'list_text'
    ));
    // Create instances on users and page nodes.
    field_create_instance(array(
      'field_name' => 'alter_test_options',
      'entity_type' => 'user',
      'bundle' => 'user',
      'widget' => array(
        'type' => 'options_select',
      )
    ));
    field_create_instance(array(
      'field_name' => 'alter_test_options',
      'entity_type' => 'node',
      'bundle' => 'page',
      'widget' => array(
        'type' => 'options_select',
      )
    ));

    // Test that field_test_field_widget_properties_user_alter() replaces
    // the widget and that field_test_field_widget_form_alter() reports the
    // correct widget name when the form is displayed.
    $this->drupalGet('admin/config/people/accounts/fields/alter_test_options');
    $this->assertText('Widget type: options_buttons', 'Widget type is altered for users in hook_field_widget_form_alter().');

    // Test that the widget is not altered on page nodes.
    $this->drupalGet('admin/structure/types/manage/page/fields/alter_test_options');
    $this->assertText('Widget type: options_select', 'Widget type is not altered for pages in hook_field_widget_form_alter().');
  }
}