file.test 51.8 KB
Newer Older
1 2 3 4
<?php

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

/**
9
 * Provides methods specifically for testing File module's field handling.
10 11 12 13 14
 */
class FileFieldTestCase extends DrupalWebTestCase {
  protected $admin_user;

  function setUp() {
15 16 17 18 19 20 21 22 23 24
    // 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[] = 'file';
    $modules[] = 'file_module_test';
    parent::setUp($modules);
25
    $this->admin_user = $this->drupalCreateUser(array('access content', 'access administration pages', 'administer site configuration', 'administer users', 'administer permissions', 'administer content types', 'administer nodes', 'bypass node access'));
26 27 28 29
    $this->drupalLogin($this->admin_user);
  }

  /**
30
   * Retrieves a sample file of the specified type.
31 32 33 34 35 36 37 38 39 40 41
   */
  function getTestFile($type_name, $size = NULL) {
    // Get a file to upload.
    $file = current($this->drupalGetTestFiles($type_name, $size));

    // Add a filesize property to files as would be read by file_load().
    $file->filesize = filesize($file->uri);

    return $file;
  }

42
  /**
43
   * Retrieves the fid of the last inserted file.
44 45 46 47 48
   */
  function getLastFileId() {
    return (int) db_query('SELECT MAX(fid) FROM {file_managed}')->fetchField();
  }

49
  /**
50
   * Creates a new file field.
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
   *
   * @param $name
   *   The name of the new field (all lowercase), exclude the "field_" prefix.
   * @param $type_name
   *   The node type that this field will be added to.
   * @param $field_settings
   *   A list of field settings that will be added to the defaults.
   * @param $instance_settings
   *   A list of instance settings that will be added to the instance defaults.
   * @param $widget_settings
   *   A list of widget settings that will be added to the widget defaults.
   */
  function createFileField($name, $type_name, $field_settings = array(), $instance_settings = array(), $widget_settings = array()) {
    $field = array(
      'field_name' => $name,
      'type' => 'file',
      'settings' => array(),
      'cardinality' => !empty($field_settings['cardinality']) ? $field_settings['cardinality'] : 1,
    );
    $field['settings'] = array_merge($field['settings'], $field_settings);
    field_create_field($field);

73 74 75 76
    $this->attachFileField($name, 'node', $type_name, $instance_settings, $widget_settings);
  }

  /**
77
   * Attaches a file field to an entity.
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
   *
   * @param $name
   *   The name of the new field (all lowercase), exclude the "field_" prefix.
   * @param $entity_type
   *   The entity type this field will be added to.
   * @param $bundle
   *   The bundle this field will be added to.
   * @param $field_settings
   *   A list of field settings that will be added to the defaults.
   * @param $instance_settings
   *   A list of instance settings that will be added to the instance defaults.
   * @param $widget_settings
   *   A list of widget settings that will be added to the widget defaults.
   */
  function attachFileField($name, $entity_type, $bundle, $instance_settings = array(), $widget_settings = array()) {
93
    $instance = array(
94
      'field_name' => $name,
95
      'label' => $name,
96 97
      'entity_type' => $entity_type,
      'bundle' => $bundle,
98 99 100 101 102 103 104 105 106 107 108 109 110
      'required' => !empty($instance_settings['required']),
      'settings' => array(),
      'widget' => array(
        'type' => 'file_generic',
        'settings' => array(),
      ),
    );
    $instance['settings'] = array_merge($instance['settings'], $instance_settings);
    $instance['widget']['settings'] = array_merge($instance['widget']['settings'], $widget_settings);
    field_create_instance($instance);
  }

  /**
111
   * Updates an existing file field with new settings.
112 113
   */
  function updateFileField($name, $type_name, $instance_settings = array(), $widget_settings = array()) {
114
    $instance = field_info_instance('node', $name, $type_name);
115 116 117 118 119 120 121
    $instance['settings'] = array_merge($instance['settings'], $instance_settings);
    $instance['widget']['settings'] = array_merge($instance['widget']['settings'], $widget_settings);

    field_update_instance($instance);
  }

  /**
122
   * Uploads a file to a node.
123
   */
124
  function uploadNodeFile($file, $field_name, $nid_or_type, $new_revision = TRUE, $extras = array()) {
125
    $langcode = LANGUAGE_NONE;
126
    $edit = array(
127
      "title" => $this->randomName(),
128 129 130 131
      'revision' => (string) (int) $new_revision,
    );

    if (is_numeric($nid_or_type)) {
132
      $nid = $nid_or_type;
133 134
    }
    else {
135
      // Add a new node.
136 137
      $extras['type'] = $nid_or_type;
      $node = $this->drupalCreateNode($extras);
138 139 140 141 142
      $nid = $node->nid;
      // Save at least one revision to better simulate a real site.
      $this->drupalCreateNode(get_object_vars($node));
      $node = node_load($nid, NULL, TRUE);
      $this->assertNotEqual($nid, $node->vid, t('Node revision exists.'));
143 144
    }

145 146 147 148 149
    // Attach a file to the node.
    $edit['files[' . $field_name . '_' . $langcode . '_0]'] = drupal_realpath($file->uri);
    $this->drupalPost("node/$nid/edit", $edit, t('Save'));

    return $nid;
150 151 152
  }

  /**
153
   * Removes a file from a node.
154 155 156 157 158 159 160 161 162 163 164 165 166
   *
   * Note that if replacing a file, it must first be removed then added again.
   */
  function removeNodeFile($nid, $new_revision = TRUE) {
    $edit = array(
      'revision' => (string) (int) $new_revision,
    );

    $this->drupalPost('node/' . $nid . '/edit', array(), t('Remove'));
    $this->drupalPost(NULL, $edit, t('Save'));
  }

  /**
167
   * Replaces a file within a node.
168 169 170
   */
  function replaceNodeFile($file, $field_name, $nid, $new_revision = TRUE) {
    $edit = array(
171
      'files[' . $field_name . '_' . LANGUAGE_NONE . '_0]' => drupal_realpath($file->uri),
172 173 174 175 176 177 178 179
      'revision' => (string) (int) $new_revision,
    );

    $this->drupalPost('node/' . $nid . '/edit', array(), t('Remove'));
    $this->drupalPost(NULL, $edit, t('Save'));
  }

  /**
180
   * Asserts that a file exists physically on disk.
181 182 183 184 185 186 187
   */
  function assertFileExists($file, $message = NULL) {
    $message = isset($message) ? $message : t('File %file exists on the disk.', array('%file' => $file->uri));
    $this->assertTrue(is_file($file->uri), $message);
  }

  /**
188
   * Asserts that a file exists in the database.
189 190
   */
  function assertFileEntryExists($file, $message = NULL) {
191
    entity_get_controller('file')->resetCache();
192 193 194 195 196 197
    $db_file = file_load($file->fid);
    $message = isset($message) ? $message : t('File %file exists in database at the correct path.', array('%file' => $file->uri));
    $this->assertEqual($db_file->uri, $file->uri, $message);
  }

  /**
198
   * Asserts that a file does not exist on disk.
199 200 201 202 203 204 205
   */
  function assertFileNotExists($file, $message = NULL) {
    $message = isset($message) ? $message : t('File %file exists on the disk.', array('%file' => $file->uri));
    $this->assertFalse(is_file($file->uri), $message);
  }

  /**
206
   * Asserts that a file does not exist in the database.
207 208
   */
  function assertFileEntryNotExists($file, $message) {
209
    entity_get_controller('file')->resetCache();
210 211 212
    $message = isset($message) ? $message : t('File %file exists in database at the correct path.', array('%file' => $file->uri));
    $this->assertFalse(file_load($file->fid), $message);
  }
213 214

  /**
215
   * Asserts that a file's status is set to permanent in the database.
216 217 218 219 220
   */
  function assertFileIsPermanent($file, $message = NULL) {
    $message = isset($message) ? $message : t('File %file is permanent.', array('%file' => $file->uri));
    $this->assertTrue($file->status == FILE_STATUS_PERMANENT, $message);
  }
221 222
}

223
/**
224
 * Tests the 'managed_file' element type.
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
 *
 * @todo Create a FileTestCase base class and move FileFieldTestCase methods
 *   that aren't related to fields into it.
 */
class FileManagedFileElementTestCase extends FileFieldTestCase {
  public static function getInfo() {
    return array(
      'name' => 'Managed file element test',
      'description' => 'Tests the managed_file element type.',
      'group' => 'File',
    );
  }

  /**
   * Tests the managed_file element type.
   */
  function testManagedFile() {
    // Perform the tests with all permutations of $form['#tree'] and
    // $element['#extended'].
    foreach (array(0, 1) as $tree) {
      foreach (array(0, 1) as $extended) {
        $test_file = $this->getTestFile('text');
        $path = 'file/test/' . $tree . '/' . $extended;
        $input_base_name = $tree ? 'nested_file' : 'file';

        // Submit without a file.
        $this->drupalPost($path, array(), t('Save'));
        $this->assertRaw(t('The file id is %fid.', array('%fid' => 0)), t('Submitted without a file.'));

        // Submit a new file, without using the Upload button.
        $last_fid_prior = $this->getLastFileId();
        $edit = array('files[' . $input_base_name . ']' => drupal_realpath($test_file->uri));
        $this->drupalPost($path, $edit, t('Save'));
        $last_fid = $this->getLastFileId();
        $this->assertTrue($last_fid > $last_fid_prior, t('New file got saved.'));
        $this->assertRaw(t('The file id is %fid.', array('%fid' => $last_fid)), t('Submit handler has correct file info.'));

        // Submit no new input, but with a default file.
        $this->drupalPost($path . '/' . $last_fid, array(), t('Save'));
        $this->assertRaw(t('The file id is %fid.', array('%fid' => $last_fid)), t('Empty submission did not change an existing file.'));

266
        // Now, test the Upload and Remove buttons, with and without Ajax.
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
        foreach (array(FALSE, TRUE) as $ajax) {
          // Upload, then Submit.
          $last_fid_prior = $this->getLastFileId();
          $this->drupalGet($path);
          $edit = array('files[' . $input_base_name . ']' => drupal_realpath($test_file->uri));
          if ($ajax) {
            $this->drupalPostAJAX(NULL, $edit, $input_base_name . '_upload_button');
          }
          else {
            $this->drupalPost(NULL, $edit, t('Upload'));
          }
          $last_fid = $this->getLastFileId();
          $this->assertTrue($last_fid > $last_fid_prior, t('New file got uploaded.'));
          $this->drupalPost(NULL, array(), t('Save'));
          $this->assertRaw(t('The file id is %fid.', array('%fid' => $last_fid)), t('Submit handler has correct file info.'));

          // Remove, then Submit.
          $this->drupalGet($path . '/' . $last_fid);
          if ($ajax) {
            $this->drupalPostAJAX(NULL, array(), $input_base_name . '_remove_button');
          }
          else {
            $this->drupalPost(NULL, array(), t('Remove'));
          }
          $this->drupalPost(NULL, array(), t('Save'));
          $this->assertRaw(t('The file id is %fid.', array('%fid' => 0)), t('Submission after file removal was successful.'));

          // Upload, then Remove, then Submit.
          $this->drupalGet($path);
          $edit = array('files[' . $input_base_name . ']' => drupal_realpath($test_file->uri));
          if ($ajax) {
            $this->drupalPostAJAX(NULL, $edit, $input_base_name . '_upload_button');
            $this->drupalPostAJAX(NULL, array(), $input_base_name . '_remove_button');
          }
          else {
            $this->drupalPost(NULL, $edit, t('Upload'));
            $this->drupalPost(NULL, array(), t('Remove'));
          }
          $this->drupalPost(NULL, array(), t('Save'));
          $this->assertRaw(t('The file id is %fid.', array('%fid' => 0)), t('Submission after file upload and removal was successful.'));
        }
      }
    }
  }
}
312 313

/**
314
 * Tests file field widget.
315 316 317 318 319
 */
class FileFieldWidgetTestCase extends FileFieldTestCase {
  public static function getInfo() {
    return array(
      'name' => 'File field widget test',
320
      'description' => 'Tests the file field widget, single and multi-valued, with and without AJAX, with public and private files.',
321 322 323 324 325
      'group' => 'File',
    );
  }

  /**
326
   * Tests upload and remove buttons for a single-valued File field.
327
   */
328
  function testSingleValuedWidget() {
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
    // Use 'page' instead of 'article', so that the 'article' image field does
    // not conflict with this test. If in the future the 'page' type gets its
    // own default file or image field, this test can be made more robust by
    // using a custom node type.
    $type_name = 'page';
    $field_name = strtolower($this->randomName());
    $this->createFileField($field_name, $type_name);
    $field = field_info_field($field_name);
    $instance = field_info_instance('node', $field_name, $type_name);

    $test_file = $this->getTestFile('text');

    foreach (array('nojs', 'js') as $type) {
      // Create a new node with the uploaded file and ensure it got uploaded
      // successfully.
344 345
      // @todo This only tests a 'nojs' submission, because drupalPostAJAX()
      //   does not yet support file uploads.
346 347 348
      $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
      $node = node_load($nid, NULL, TRUE);
      $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
349
      $this->assertFileExists($node_file, t('New file saved to disk on node creation.'));
350 351

      // Ensure the file can be downloaded.
352
      $this->drupalGet(file_create_url($node_file->uri));
353
      $this->assertResponse(200, t('Confirmed that the generated URL is correct by downloading the shipped file.'));
354 355 356

      // Ensure the edit page has a remove button instead of an upload button.
      $this->drupalGet("node/$nid/edit");
357 358
      $this->assertNoFieldByXPath('//input[@type="submit"]', t('Upload'), t('Node with file does not display the "Upload" button.'));
      $this->assertFieldByXpath('//input[@type="submit"]', t('Remove'), t('Node with file displays the "Remove" button.'));
359 360 361 362 363 364 365 366

      // "Click" the remove button (emulating either a nojs or js submission).
      switch ($type) {
        case 'nojs':
          $this->drupalPost(NULL, array(), t('Remove'));
          break;
        case 'js':
          $button = $this->xpath('//input[@type="submit" and @value="' . t('Remove') . '"]');
367
          $this->drupalPostAJAX(NULL, array(), array((string) $button[0]['name'] => (string) $button[0]['value']));
368 369 370 371
          break;
      }

      // Ensure the page now has an upload button instead of a remove button.
372 373
      $this->assertNoFieldByXPath('//input[@type="submit"]', t('Remove'), t('After clicking the "Remove" button, it is no longer displayed.'));
      $this->assertFieldByXpath('//input[@type="submit"]', t('Upload'), t('After clicking the "Remove" button, the "Upload" button is displayed.'));
374 375 376 377

      // Save the node and ensure it does not have the file.
      $this->drupalPost(NULL, array(), t('Save'));
      $node = node_load($nid, NULL, TRUE);
378
      $this->assertTrue(empty($node->{$field_name}[LANGUAGE_NONE][0]['fid']), t('File was successfully removed from the node.'));
379
    }
380
  }
381

382
  /**
383
   * Tests upload and remove buttons for multiple multi-valued File fields.
384 385 386 387 388 389 390 391
   */
  function testMultiValuedWidget() {
    // Use 'page' instead of 'article', so that the 'article' image field does
    // not conflict with this test. If in the future the 'page' type gets its
    // own default file or image field, this test can be made more robust by
    // using a custom node type.
    $type_name = 'page';
    $field_name = strtolower($this->randomName());
392
    $field_name2 = strtolower($this->randomName());
393
    $this->createFileField($field_name, $type_name, array('cardinality' => 3));
394 395
    $this->createFileField($field_name2, $type_name, array('cardinality' => 3));

396 397 398
    $field = field_info_field($field_name);
    $instance = field_info_instance('node', $field_name, $type_name);

399 400 401
    $field2 = field_info_field($field_name2);
    $instance2 = field_info_instance('node', $field_name2, $type_name);

402 403 404
    $test_file = $this->getTestFile('text');

    foreach (array('nojs', 'js') as $type) {
405 406 407 408 409
      // Visit the node creation form, and upload 3 files for each field. Since
      // the field has cardinality of 3, ensure the "Upload" button is displayed
      // until after the 3rd file, and after that, isn't displayed. Because
      // SimpleTest triggers the last button with a given name, so upload to the
      // second field first.
410
      // @todo This is only testing a non-Ajax upload, because drupalPostAJAX()
411
      //   does not yet emulate jQuery's file upload.
412
      //
413
      $this->drupalGet("node/add/$type_name");
414 415 416 417 418 419
      foreach (array($field_name2, $field_name) as $each_field_name) {
        for ($delta = 0; $delta < 3; $delta++) {
          $edit = array('files[' . $each_field_name . '_' . LANGUAGE_NONE . '_' . $delta . ']' => drupal_realpath($test_file->uri));
          // If the Upload button doesn't exist, drupalPost() will automatically
          // fail with an assertion message.
          $this->drupalPost(NULL, $edit, t('Upload'));
420
        }
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
      }
      $this->assertNoFieldByXpath('//input[@type="submit"]', t('Upload'), t('After uploading 3 files for each field, the "Upload" button is no longer displayed.'));

      $num_expected_remove_buttons = 6;

      foreach (array($field_name, $field_name2) as $current_field_name) {
        // How many uploaded files for the current field are remaining.
        $remaining = 3;
        // Test clicking each "Remove" button. For extra robustness, test them out
        // of sequential order. They are 0-indexed, and get renumbered after each
        // iteration, so array(1, 1, 0) means:
        // - First remove the 2nd file.
        // - Then remove what is then the 2nd file (was originally the 3rd file).
        // - Then remove the first file.
        foreach (array(1,1,0) as $delta) {
          // Ensure we have the expected number of Remove buttons, and that they
          // are numbered sequentially.
          $buttons = $this->xpath('//input[@type="submit" and @value="Remove"]');
          $this->assertTrue(is_array($buttons) && count($buttons) === $num_expected_remove_buttons, t('There are %n "Remove" buttons displayed (JSMode=%type).', array('%n' => $num_expected_remove_buttons, '%type' => $type)));
          foreach ($buttons as $i => $button) {
            $key = $i >= $remaining ? $i - $remaining : $i;
            $check_field_name = $field_name2;
            if ($current_field_name == $field_name && $i < $remaining) {
              $check_field_name = $field_name;
            }
446

447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
            $this->assertIdentical((string) $button['name'], $check_field_name . '_' . LANGUAGE_NONE . '_' . $key. '_remove_button');
          }

          // "Click" the remove button (emulating either a nojs or js submission).
          $button_name = $current_field_name . '_' . LANGUAGE_NONE . '_' . $delta . '_remove_button';
          switch ($type) {
            case 'nojs':
              // drupalPost() takes a $submit parameter that is the value of the
              // button whose click we want to emulate. Since we have multiple
              // buttons with the value "Remove", and want to control which one we
              // use, we change the value of the other ones to something else.
              // Since non-clicked buttons aren't included in the submitted POST
              // data, and since drupalPost() will result in $this being updated
              // with a newly rebuilt form, this doesn't cause problems.
              foreach ($buttons as $button) {
                if ($button['name'] != $button_name) {
                  $button['value'] = 'DUMMY';
                }
465
              }
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
              $this->drupalPost(NULL, array(), t('Remove'));
              break;
            case 'js':
              // drupalPostAJAX() lets us target the button precisely, so we don't
              // require the workaround used above for nojs.
              $this->drupalPostAJAX(NULL, array(), array($button_name => t('Remove')));
              break;
          }
          $num_expected_remove_buttons--;
          $remaining--;

          // Ensure an "Upload" button for the current field is displayed with the
          // correct name.
          $upload_button_name = $current_field_name . '_' . LANGUAGE_NONE . '_' . $remaining . '_upload_button';
          $buttons = $this->xpath('//input[@type="submit" and @value="Upload" and @name=:name]', array(':name' => $upload_button_name));
          $this->assertTrue(is_array($buttons) && count($buttons) == 1, t('The upload button is displayed with the correct name (JSMode=%type).', array('%type' => $type)));

          // Ensure only at most one button per field is displayed.
          $buttons = $this->xpath('//input[@type="submit" and @value="Upload"]');
          $expected = $current_field_name == $field_name ? 1 : 2;
          $this->assertTrue(is_array($buttons) && count($buttons) == $expected, t('After removing a file, only one "Upload" button for each possible field is displayed (JSMode=%type).', array('%type' => $type)));
487 488 489 490
        }
      }

      // Ensure the page now has no Remove buttons.
491
      $this->assertNoFieldByXPath('//input[@type="submit"]', t('Remove'), t('After removing all files, there is no "Remove" button displayed (JSMode=%type).', array('%type' => $type)));
492

493 494 495 496 497 498 499
      // Save the node and ensure it does not have any files.
      $this->drupalPost(NULL, array('title' => $this->randomName()), t('Save'));
      $matches = array();
      preg_match('/node\/([0-9]+)/', $this->getUrl(), $matches);
      $nid = $matches[1];
      $node = node_load($nid, NULL, TRUE);
      $this->assertTrue(empty($node->{$field_name}[LANGUAGE_NONE][0]['fid']), t('Node was successfully saved without any files.'));
500
    }
501
  }
502

503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
  /**
   * Tests a file field with a "Private files" upload destination setting.
   */
  function testPrivateFileSetting() {
    // Use 'page' instead of 'article', so that the 'article' image field does
    // not conflict with this test. If in the future the 'page' type gets its
    // own default file or image field, this test can be made more robust by
    // using a custom node type.
    $type_name = 'page';
    $field_name = strtolower($this->randomName());
    $this->createFileField($field_name, $type_name);
    $field = field_info_field($field_name);
    $instance = field_info_instance('node', $field_name, $type_name);

    $test_file = $this->getTestFile('text');

    // Change the field setting to make its files private, and upload a file.
520 521 522 523 524
    $edit = array('field[settings][uri_scheme]' => 'private');
    $this->drupalPost("admin/structure/types/manage/$type_name/fields/$field_name", $edit, t('Save settings'));
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
    $node = node_load($nid, NULL, TRUE);
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
525
    $this->assertFileExists($node_file, t('New file saved to disk on node creation.'));
526 527

    // Ensure the private file is available to the user who uploaded it.
528
    $this->drupalGet(file_create_url($node_file->uri));
529
    $this->assertResponse(200, t('Confirmed that the generated URL is correct by downloading the shipped file.'));
530

531 532 533
    // Ensure we can't change 'uri_scheme' field settings while there are some
    // entities with uploaded files.
    $this->drupalGet("admin/structure/types/manage/$type_name/fields/$field_name");
534
    $this->assertFieldByXpath('//input[@id="edit-field-settings-uri-scheme-public" and @disabled="disabled"]', 'public', t('Upload destination setting disabled.'));
535

536 537 538
    // Delete node and confirm that setting could be changed.
    node_delete($nid);
    $this->drupalGet("admin/structure/types/manage/$type_name/fields/$field_name");
539
    $this->assertFieldByXpath('//input[@id="edit-field-settings-uri-scheme-public" and not(@disabled)]', 'public', t('Upload destination setting enabled.'));
540
  }
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555

  /**
   * Tests that download restrictions on private files work on comments.
   */
  function testPrivateFileComment() {
    $user = $this->drupalCreateUser(array('access comments'));

    // Remove access comments permission from anon user.
    $edit = array(
      '1[access comments]' => FALSE,
    );
    $this->drupalPost('admin/people/permissions', $edit, t('Save permissions'));

    // Create a new field.
    $edit = array(
556 557 558 559
      'fields[_add_new_field][label]' => $label = $this->randomName(),
      'fields[_add_new_field][field_name]' => $name = strtolower($this->randomName()),
      'fields[_add_new_field][type]' => 'file',
      'fields[_add_new_field][widget_type]' => 'file_generic',
560 561 562 563 564 565 566 567 568 569 570 571
    );
    $this->drupalPost('admin/structure/types/manage/article/comment/fields', $edit, t('Save'));
    $edit = array('field[settings][uri_scheme]' => 'private');
    $this->drupalPost(NULL, $edit, t('Save field settings'));
    $this->drupalPost(NULL, array(), t('Save settings'));

    // Create node.
    $text_file = $this->getTestFile('text');
    $edit = array(
      'title' => $this->randomName(),
    );
    $this->drupalPost('node/add/article', $edit, t('Save'));
572
    $node = $this->drupalGetNodeByTitle($edit['title']);
573 574 575 576

    // Add a comment with a file.
    $text_file = $this->getTestFile('text');
    $edit = array(
577
      'files[field_' . $name . '_' . LANGUAGE_NONE . '_' . 0 . ']' => drupal_realpath($text_file->uri),
578 579 580 581 582 583 584 585 586 587
      'comment_body[' . LANGUAGE_NONE . '][0][value]' => $comment_body = $this->randomName(),
    );
    $this->drupalPost(NULL, $edit, t('Save'));

    // Get the comment ID.
    preg_match('/comment-([0-9]+)/', $this->getUrl(), $matches);
    $cid = $matches[1];

    // Log in as normal user.
    $this->drupalLogin($user);
588

589 590 591 592 593 594 595 596
    $comment = comment_load($cid);
    $comment_file = (object) $comment->{'field_' . $name}[LANGUAGE_NONE][0];
    $this->assertFileExists($comment_file, t('New file saved to disk on node creation.'));
    // Test authenticated file download.
    $url = file_create_url($comment_file->uri);
    $this->assertNotEqual($url, NULL, t('Confirmed that the URL is valid'));
    $this->drupalGet(file_create_url($comment_file->uri));
    $this->assertResponse(200, t('Confirmed that the generated URL is correct by downloading the shipped file.'));
597

598 599 600 601
    // Test anonymous file download.
    $this->drupalLogout();
    $this->drupalGet(file_create_url($comment_file->uri));
    $this->assertResponse(403, t('Confirmed that access is denied for the file without the needed permission.'));
602 603 604 605 606 607 608 609 610 611 612 613

    // Unpublishes node.
    $this->drupalLogin($this->admin_user);
    $edit = array(
      'status' => FALSE,
    );
    $this->drupalPost('node/' . $node->nid . '/edit', $edit, t('Save'));

    // Ensures normal user can no longer download the file.
    $this->drupalLogin($user);
    $this->drupalGet(file_create_url($comment_file->uri));
    $this->assertResponse(403, t('Confirmed that access is denied for the file without the needed permission.'));
614 615
  }

616 617
}

618
/**
619
 * Tests file handling with node revisions.
620 621
 */
class FileFieldRevisionTestCase extends FileFieldTestCase {
622
  public static function getInfo() {
623
    return array(
624 625 626
      'name' => 'File field revision test',
      'description' => 'Test creating and deleting revisions with files attached.',
      'group' => 'File',
627 628 629 630
    );
  }

  /**
631
   * Tests creating multiple revisions of a node and managing attached files.
632 633 634 635 636 637 638 639 640 641 642
   *
   * Expected behaviors:
   *  - Adding a new revision will make another entry in the field table, but
   *    the original file will not be duplicated.
   *  - Deleting a revision should not delete the original file if the file
   *    is in use by another revision.
   *  - When the last revision that uses a file is deleted, the original file
   *    should be deleted also.
   */
  function testRevisions() {
    $type_name = 'article';
643
    $field_name = strtolower($this->randomName());
644 645
    $this->createFileField($field_name, $type_name);
    $field = field_info_field($field_name);
646
    $instance = field_info_instance('node', $field_name, $type_name);
647

648 649 650
    // Attach the same fields to users.
    $this->attachFileField($field_name, 'user', 'user');

651 652 653 654 655 656 657
    $test_file = $this->getTestFile('text');

    // Create a new node with the uploaded file.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);

    // Check that the file exists on disk and in the database.
    $node = node_load($nid, NULL, TRUE);
658
    $node_file_r1 = (object) $node->{$field_name}[LANGUAGE_NONE][0];
659
    $node_vid_r1 = $node->vid;
660 661 662
    $this->assertFileExists($node_file_r1, t('New file saved to disk on node creation.'));
    $this->assertFileEntryExists($node_file_r1, t('File entry exists in database on node creation.'));
    $this->assertFileIsPermanent($node_file_r1, t('File is permanent.'));
663 664 665 666

    // Upload another file to the same node in a new revision.
    $this->replaceNodeFile($test_file, $field_name, $nid);
    $node = node_load($nid, NULL, TRUE);
667
    $node_file_r2 = (object) $node->{$field_name}[LANGUAGE_NONE][0];
668
    $node_vid_r2 = $node->vid;
669 670 671
    $this->assertFileExists($node_file_r2, t('Replacement file exists on disk after creating new revision.'));
    $this->assertFileEntryExists($node_file_r2, t('Replacement file entry exists in database after creating new revision.'));
    $this->assertFileIsPermanent($node_file_r2, t('Replacement file is permanent.'));
672 673 674

    // Check that the original file is still in place on the first revision.
    $node = node_load($nid, $node_vid_r1, TRUE);
675 676 677 678
    $this->assertEqual($node_file_r1, (object) $node->{$field_name}[LANGUAGE_NONE][0], t('Original file still in place after replacing file in new revision.'));
    $this->assertFileExists($node_file_r1, t('Original file still in place after replacing file in new revision.'));
    $this->assertFileEntryExists($node_file_r1, t('Original file entry still in place after replacing file in new revision'));
    $this->assertFileIsPermanent($node_file_r1, t('Original file is still permanent.'));
679 680 681 682 683

    // Save a new version of the node without any changes.
    // Check that the file is still the same as the previous revision.
    $this->drupalPost('node/' . $nid . '/edit', array('revision' => '1'), t('Save'));
    $node = node_load($nid, NULL, TRUE);
684
    $node_file_r3 = (object) $node->{$field_name}[LANGUAGE_NONE][0];
685
    $node_vid_r3 = $node->vid;
686 687
    $this->assertEqual($node_file_r2, $node_file_r3, t('Previous revision file still in place after creating a new revision without a new file.'));
    $this->assertFileIsPermanent($node_file_r3, t('New revision file is permanent.'));
688 689 690 691

    // Revert to the first revision and check that the original file is active.
    $this->drupalPost('node/' . $nid . '/revisions/' . $node_vid_r1 . '/revert', array(), t('Revert'));
    $node = node_load($nid, NULL, TRUE);
692
    $node_file_r4 = (object) $node->{$field_name}[LANGUAGE_NONE][0];
693
    $node_vid_r4 = $node->vid;
694 695
    $this->assertEqual($node_file_r1, $node_file_r4, t('Original revision file still in place after reverting to the original revision.'));
    $this->assertFileIsPermanent($node_file_r4, t('Original revision file still permanent after reverting to the original revision.'));
696 697 698 699

    // Delete the second revision and check that the file is kept (since it is
    // still being used by the third revision).
    $this->drupalPost('node/' . $nid . '/revisions/' . $node_vid_r2 . '/delete', array(), t('Delete'));
700 701 702
    $this->assertFileExists($node_file_r3, t('Second file is still available after deleting second revision, since it is being used by the third revision.'));
    $this->assertFileEntryExists($node_file_r3, t('Second file entry is still available after deleting second revision, since it is being used by the third revision.'));
    $this->assertFileIsPermanent($node_file_r3, t('Second file entry is still permanent after deleting second revision, since it is being used by the third revision.'));
703

704 705
    // Attach the second file to a user.
    $user = $this->drupalCreateUser();
706
    $edit = (array) $user;
707 708 709 710 711
    $edit[$field_name][LANGUAGE_NONE][0] = (array) $node_file_r3;
    user_save($user, $edit);
    $this->drupalGet('user/' . $user->uid . '/edit');

    // Delete the third revision and check that the file is not deleted yet.
712
    $this->drupalPost('node/' . $nid . '/revisions/' . $node_vid_r3 . '/delete', array(), t('Delete'));
713 714 715
    $this->assertFileExists($node_file_r3, t('Second file is still available after deleting third revision, since it is being used by the user.'));
    $this->assertFileEntryExists($node_file_r3, t('Second file entry is still available after deleting third revision, since it is being used by the user.'));
    $this->assertFileIsPermanent($node_file_r3, t('Second file entry is still permanent after deleting third revision, since it is being used by the user.'));
716 717 718

    // Delete the user and check that the file is also deleted.
    user_delete($user->uid);
719 720 721 722
    // TODO: This seems like a bug in File API. Clearing the stat cache should
    // not be necessary here. The file really is deleted, but stream wrappers
    // doesn't seem to think so unless we clear the PHP file stat() cache.
    clearstatcache();
723 724
    $this->assertFileNotExists($node_file_r3, t('Second file is now deleted after deleting third revision, since it is no longer being used by any other nodes.'));
    $this->assertFileEntryNotExists($node_file_r3, t('Second file entry is now deleted after deleting third revision, since it is no longer being used by any other nodes.'));
725 726 727

    // Delete the entire node and check that the original file is deleted.
    $this->drupalPost('node/' . $nid . '/delete', array(), t('Delete'));
728 729
    $this->assertFileNotExists($node_file_r1, t('Original file is deleted after deleting the entire node with two revisions remaining.'));
    $this->assertFileEntryNotExists($node_file_r1, t('Original file entry is deleted after deleting the entire node with two revisions remaining.'));
730 731 732 733
  }
}

/**
734
 * Tests that formatters are working properly.
735 736
 */
class FileFieldDisplayTestCase extends FileFieldTestCase {
737
  public static function getInfo() {
738
    return array(
739 740 741
      'name' => 'File field display tests',
      'description' => 'Test the display of file fields in node and views.',
      'group' => 'File',
742 743 744 745
    );
  }

  /**
746
   * Tests normal formatter display on node display.
747 748
   */
  function testNodeDisplay() {
749
    $field_name = strtolower($this->randomName());
750 751 752 753 754
    $type_name = 'article';
    $field_settings = array(
      'display_field' => '1',
      'display_default' => '1',
    );
755
    $instance_settings = array(
756 757
      'description_field' => '1',
    );
758
    $widget_settings = array();
759 760
    $this->createFileField($field_name, $type_name, $field_settings, $instance_settings, $widget_settings);
    $field = field_info_field($field_name);
761
    $instance = field_info_instance('node', $field_name, $type_name);
762

763 764 765 766 767 768 769 770 771 772 773 774 775
    // Create a new node *without* the file field set, and check that the field
    // is not shown for each node display.
    $node = $this->drupalCreateNode(array('type' => $type_name));
    $file_formatters = array('file_default', 'file_table', 'file_url_plain', 'hidden');
    foreach ($file_formatters as $formatter) {
      $edit = array(
        "fields[$field_name][type]" => $formatter,
      );
      $this->drupalPost("admin/structure/types/manage/$type_name/display", $edit, t('Save'));
      $this->drupalGet('node/' . $node->nid);
      $this->assertNoText($field_name, t('Field label is hidden when no file attached for formatter %formatter', array('%formatter' => $formatter)));
    }

776 777 778 779 780 781 782 783
    $test_file = $this->getTestFile('text');

    // Create a new node with the uploaded file.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
    $this->drupalGet('node/' . $nid . '/edit');

    // Check that the default formatter is displaying with the file name.
    $node = node_load($nid, NULL, TRUE);
784
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
785
    $default_output = theme('file_link', array('file' => $node_file));
786
    $this->assertRaw($default_output, t('Default formatter displaying correctly on full node view.'));
787 788

    // Turn the "display" option off and check that the file is no longer displayed.
789
    $edit = array($field_name . '[' . LANGUAGE_NONE . '][0][display]' => FALSE);
790 791
    $this->drupalPost('node/' . $nid . '/edit', $edit, t('Save'));

792
    $this->assertNoRaw($default_output, t('Field is hidden when "display" option is unchecked.'));
793 794 795 796 797

  }
}

/**
798
 * Tests various validations.
799 800 801 802 803
 */
class FileFieldValidateTestCase extends FileFieldTestCase {
  protected $field;
  protected $node_type;

804
  public static function getInfo() {
805
    return array(
806 807 808
      'name' => 'File field validation tests',
      'description' => 'Tests validation functions such as file type, max file size, max size per node, and required.',
      'group' => 'File',
809 810 811 812
    );
  }

  /**
813
   * Tests the required property on file fields.
814 815 816
   */
  function testRequired() {
    $type_name = 'article';
817
    $field_name = strtolower($this->randomName());
818 819
    $this->createFileField($field_name, $type_name, array(), array('required' => '1'));
    $field = field_info_field($field_name);
820
    $instance = field_info_instance('node', $field_name, $type_name);
821 822 823 824

    $test_file = $this->getTestFile('text');

    // Try to post a new node without uploading a file.
825
    $langcode = LANGUAGE_NONE;
826
    $edit = array("title" => $this->randomName());
827
    $this->drupalPost('node/add/' . $type_name, $edit, t('Save'));
828
    $this->assertRaw(t('!title field is required.', array('!title' => $instance['label'])), t('Node save failed when required file field was empty.'));
829 830 831

    // Create a new node with the uploaded file.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
832 833
    $this->assertTrue($nid !== FALSE, t('uploadNodeFile(@test_file, @field_name, @type_name) succeeded', array('@test_file' => $test_file->uri, '@field_name' => $field_name, '@type_name' => $type_name)));

834 835
    $node = node_load($nid, NULL, TRUE);

836
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
837 838
    $this->assertFileExists($node_file, t('File exists after uploading to the required field.'));
    $this->assertFileEntryExists($node_file, t('File entry exists after uploading to the required field.'));
839 840 841 842 843 844

    // Try again with a multiple value field.
    field_delete_field($field_name);
    $this->createFileField($field_name, $type_name, array('cardinality' => FIELD_CARDINALITY_UNLIMITED), array('required' => '1'));

    // Try to post a new node without uploading a file in the multivalue field.
845
    $edit = array('title' => $this->randomName());
846
    $this->drupalPost('node/add/' . $type_name, $edit, t('Save'));
847
    $this->assertRaw(t('!title field is required.', array('!title' => $instance['label'])), t('Node save failed when required multiple value file field was empty.'));
848 849 850 851

    // Create a new node with the uploaded file into the multivalue field.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
    $node = node_load($nid, NULL, TRUE);
852
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
853 854
    $this->assertFileExists($node_file, t('File exists after uploading to the required multiple value field.'));
    $this->assertFileEntryExists($node_file, t('File entry exists after uploading to the required multipel value field.'));
855 856 857 858 859 860

    // Remove our file field.
    field_delete_field($field_name);
  }

  /**
861
   * Tests the max file size validator.
862 863 864
   */
  function testFileMaxSize() {
    $type_name = 'article';
865
    $field_name = strtolower($this->randomName());
866 867
    $this->createFileField($field_name, $type_name, array(), array('required' => '1'));
    $field = field_info_field($field_name);
868
    $instance = field_info_instance('node', $field_name, $type_name);
869 870 871 872 873 874 875 876 877 878 879 880 881 882

    $small_file = $this->getTestFile('text', 131072); // 128KB.
    $large_file = $this->getTestFile('text', 1310720); // 1.2MB

    // Test uploading both a large and small file with different increments.
    $sizes = array(
      '1M' => 1048576,
      '1024K' => 1048576,
      '1048576' => 1048576,
    );

    foreach ($sizes as $max_filesize => $file_limit) {
      // Set the max file upload size.
      $this->updateFileField($field_name, $type_name, array('max_filesize' => $max_filesize));
883
      $instance = field_info_instance('node', $field_name, $type_name);
884 885 886 887

      // Create a new node with the small file, which should pass.
      $nid = $this->uploadNodeFile($small_file, $field_name, $type_name);
      $node = node_load($nid, NULL, TRUE);
888
      $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
889 890
      $this->assertFileExists($node_file, t('File exists after uploading a file (%filesize) under the max limit (%maxsize).', array('%filesize' => format_size($small_file->filesize), '%maxsize' => $max_filesize)));
      $this->assertFileEntryExists($node_file, t('File entry exists after uploading a file (%filesize) under the max limit (%maxsize).', array('%filesize' => format_size($small_file->filesize), '%maxsize' => $max_filesize)));
891 892 893 894

      // Check that uploading the large file fails (1M limit).
      $nid = $this->uploadNodeFile($large_file, $field_name, $type_name);
      $error_message = t('The file is %filesize exceeding the maximum file size of %maxsize.', array('%filesize' => format_size($large_file->filesize), '%maxsize' => format_size($file_limit)));
895
      $this->assertRaw($error_message, t('Node save failed when file (%filesize) exceeded the max upload size (%maxsize).', array('%filesize' => format_size($large_file->filesize), '%maxsize' => $max_filesize)));
896 897 898 899 900 901 902 903
    }

    // Turn off the max filesize.
    $this->updateFileField($field_name, $type_name, array('max_filesize' => ''));

    // Upload the big file successfully.
    $nid = $this->uploadNodeFile($large_file, $field_name, $type_name);
    $node = node_load($nid, NULL, TRUE);
904
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
905 906
    $this->assertFileExists($node_file, t('File exists after uploading a file (%filesize) with no max limit.', array('%filesize' => format_size($large_file->filesize))));
    $this->assertFileEntryExists($node_file, t('File entry exists after uploading a file (%filesize) with no max limit.', array('%filesize' => format_size($large_file->filesize))));
907 908 909 910 911 912

    // Remove our file field.
    field_delete_field($field_name);
  }

  /**
913
   * Tests file extension checking.
914 915 916
   */
  function testFileExtension() {
    $type_name = 'article';
917
    $field_name = strtolower($this->randomName());
918 919
    $this->createFileField($field_name, $type_name);
    $field = field_info_field($field_name);
920
    $instance = field_info_instance('node', $field_name, $type_name);
921 922

    $test_file = $this->getTestFile('image');
923
    list(, $test_file_extension) = explode('.', $test_file->filename);
924 925 926 927 928 929 930

    // Disable extension checking.
    $this->updateFileField($field_name, $type_name, array('file_extensions' => ''));

    // Check that the file can be uploaded with no extension checking.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
    $node = node_load($nid, NULL, TRUE);
931
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
932 933
    $this->assertFileExists($node_file, t('File exists after uploading a file with no extension checking.'));
    $this->assertFileEntryExists($node_file, t('File entry exists after uploading a file with no extension checking.'));
934 935 936 937 938 939 940

    // Enable extension checking for text files.
    $this->updateFileField($field_name, $type_name, array('file_extensions' => 'txt'));

    // Check that the file with the wrong extension cannot be uploaded.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
    $error_message = t('Only files with the following extensions are allowed: %files-allowed.', array('%files-allowed' => 'txt'));
941
    $this->assertRaw($error_message, t('Node save failed when file uploaded with the wrong extension.'));
942 943

    // Enable extension checking for text and image files.
944
    $this->updateFileField($field_name, $type_name, array('file_extensions' => "txt $test_file_extension"));
945 946 947 948

    // Check that the file can be uploaded with extension checking.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
    $node = node_load($nid, NULL, TRUE);
949
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
950 951
    $this->assertFileExists($node_file, t('File exists after uploading a file with extension checking.'));
    $this->assertFileEntryExists($node_file, t('File entry exists after uploading a file with extension checking.'));
952 953 954 955 956 957 958

    // Remove our file field.
    field_delete_field($field_name);
  }
}

/**
959
 * Tests that files are uploaded to proper locations.
960 961
 */
class FileFieldPathTestCase extends FileFieldTestCase {
962
  public static function getInfo() {
963
    return array(
964 965 966
      'name' => 'File field file path tests',
      'description' => 'Test that files are uploaded to the proper location with token support.',
      'group' => 'File',
967 968 969 970
    );
  }

  /**
971
   * Tests the normal formatter display on node display.
972 973
   */
  function testUploadPath() {
974
    $field_name = strtolower($this->randomName());
975 976 977 978 979 980 981 982 983
    $type_name = 'article';
    $field = $this->createFileField($field_name, $type_name);
    $test_file = $this->getTestFile('text');

    // Create a new node.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);

    // Check that the file was uploaded to the file root.
    $node = node_load($nid, NULL, TRUE);
984
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
985
    $this->assertPathMatch('public://' . $test_file->filename, $node_file->uri, t('The file %file was uploaded to the correct path.', array('%file' => $node_file->uri)));
986 987 988 989 990 991 992 993 994

    // Change the path to contain multiple subdirectories.
    $field = $this->updateFileField($field_name, $type_name, array('file_directory' => 'foo/bar/baz'));

    // Upload a new file into the subdirectories.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);

    // Check that the file was uploaded into the subdirectory.
    $node = node_load($nid, NULL, TRUE);
995
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
996
    $this->assertPathMatch('public://foo/bar/baz/' . $test_file->filename, $node_file->uri, t('The file %file was uploaded to the correct path.', array('%file' => $node_file->uri)));
997 998 999

    // Check the path when used with tokens.
    // Change the path to contain multiple token directories.
1000
    $field = $this->updateFileField($field_name, $type_name, array('file_directory' => '[current-user:uid]/[current-user:name]'));
1001 1002 1003 1004 1005 1006

    // Upload a new file into the token subdirectories.
    $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);

    // Check that the file was uploaded into the subdirectory.
    $node = node_load($nid, NULL, TRUE);
1007
    $node_file = (object) $node->{$field_name}[LANGUAGE_NONE][0];
1008 1009
    // Do token replacement using the same user which uploaded the file, not
    // the user running the test case.
1010 1011
    $data = array('user' => $this->admin_user);
    $subdirectory = token_replace('[user:uid]/[user:name]', $data);
1012
    $this->assertPathMatch('public://' . $subdirectory . '/' . $test_file->filename, $node_file->uri, t('The file %file was uploaded to the correct path with token replacements.', array('%file' => $node_file->uri)));