class FileUploadWizardTestCase

class FileUploadWizardTestCase extends FileTestHelper {

  function setUp() {
    parent::setUp();

    $this->private_files_directory = config_get('system.core', 'file_private_path');
    // Disable the private file system which is automatically enabled by
    // BackdropTestCase so we can test the upload wizard correctly.
    config_set('system.core', 'file_private_path', '');

    $web_user = $this->backdropCreateUser(array(
      'create files',
      'view files',
      'view own private files',
      'manage files',
    ));
    $this->backdropLogin($web_user);
  }

  /**
   * Test the basic file upload wizard functionality.
   */
  function testFileUploadWizardBasic() {
    $test_file = $this->getTestFile('text');

    // Step 1: Upload a basic document file.
    $edit = array();
    $edit['files[upload]'] = backdrop_realpath($test_file->uri);
    $this->backdropPost('file/add', $edit, t('Next'));

    // Check that the file exists in the database.
    $fid = $this->getLastFileId();
    $file = file_load($fid);
    $this->assertTrue($file, t('File found in database.'));

    // Check that the document file has been uploaded.
    $this->assertRaw(t('@type %name was uploaded.', array('@type' => 'Document', '%name' => $file->filename)), t('Document file uploaded.'));
  }

  /**
   * Test the file upload wizard type step.
   */
  function testFileUploadWizardTypes() {
    $test_file = $this->getTestFile('text');

    // Create multiple file types with the same mime types.
    $this->createFileType(array('type' => 'document1', 'name' => 'Document 1', 'mimetypes' => array('text/plain')));
    $this->createFileType(array('type' => 'document2', 'name' => 'Document 2', 'mimetypes' => array('text/plain')));

    // Step 1: Upload a basic document file.
    $edit = array();
    $edit['files[upload]'] = backdrop_realpath($test_file->uri);
    $this->backdropPost('file/add', $edit, t('Next'));

    // Step 2: File type selection.
    $edit = array();
    $edit['type'] = 'document2';
    $this->backdropPost(NULL, $edit, t('Next'));

    // Check that the file exists in the database.
    $fid = $this->getLastFileId();
    $file = file_load($fid);
    $this->assertTrue($file, t('File found in database.'));

    // Check that the document file has been uploaded.
    $this->assertRaw(t('@type %name was uploaded.', array('@type' => 'Document 2', '%name' => $file->filename)), t('Document 2 file uploaded.'));
  }

  /**
   * Test the file upload wizard scheme step.
   */
  function testFileUploadWizardSchemes() {
    $test_file = $this->getTestFile('text');

    // Enable the private file system.
    config_set('system.core', 'file_private_path', $this->private_files_directory);

    // Step 1: Upload a basic document file.
    $edit = array();
    $edit['files[upload]'] = backdrop_realpath($test_file->uri);
    $this->backdropPost('file/add', $edit, t('Next'));

    // Step 3: Scheme selection.
    $edit = array();
    $edit['scheme'] = 'private';
    $this->backdropPost(NULL, $edit, t('Next'));

    // Check that the file exists in the database.
    $fid = $this->getLastFileId();
    $file = file_load($fid);
    $this->assertTrue($file, t('File found in database.'));

    // Check that the document file has been uploaded.
    $this->assertRaw(t('@type %name was uploaded.', array('@type' => 'Document', '%name' => $file->filename)), t('Document file uploaded privately.'));
  }

  /**
   * Test the file upload wizard when uploading a private file fails.
   */
  function testFileUploadWizardPrivateFailure() {
    $test_file = $this->getTestFile('text');

    // Record the last saved file ID.
    $previous_last_fid = $this->getLastFileId();

    // Enable the private file system.
    config_set('system.core', 'file_private_path', $this->private_files_directory);

    // Step 1: Upload a basic document file.
    $edit = array();
    $edit['files[upload]'] = backdrop_realpath($test_file->uri);
    $this->backdropPost('file/add', $edit, t('Next'));

    // After the file is uploaded but before the file is saved to its final
    // location, update the private files directory to an non-writable location.
    // The /root directory is the home directory of the root user, and should
    // never be writable by the web user. As long as the directory either does
    // not exist, or is not writable, this example should work.
    $temp_private_location = '/root';
    config_set('system.core', 'file_private_path', $temp_private_location);

    // Now the file is in a temporary location. Load its entity.
    $new_fid = $this->getLastFileId();
    $new_file = file_load($new_fid);
    $this->assertTrue(file_exists($new_file->uri), 'File is temporarily uploaded.');

    // Step 3: Scheme selection.
    $edit = array();
    $edit['scheme'] = 'private';
    $this->backdropPost(NULL, $edit, t('Next'));

    // Check that a message was printed indicating the file was not saved.
    $this->assertRaw(t('@type %name was not saved.', array('@type' => 'Document', '%name' => $test_file->filename)), 'Failed private upload was deleted.');

    // Check that the file is no longer on disk.
    clearstatcache($new_file->uri);
    $this->assertFalse(file_exists($new_file->uri), 'Temporary file on disk has been deleted.');

    // Check that the file entity was deleted.
    $last_fid = $this->getLastFileId();
    $this->assertTrue($previous_last_fid == $last_fid, 'Latest file entity remains the same.');
    $this->assertFalse($new_fid == $last_fid, 'New file entity was deleted when file fails to upload.');

    // Reset the private file path so the testing framework doesn't try to
    // clean up the non-writable directory.
    config_clear('system.core', 'file_private_path');
  }

  /**
   * Test the file upload wizard field step.
   */
  function testFileUploadWizardFields() {
    $test_file = $this->getTestFile('image');
    $filename = $this->randomName();
    $alt = $this->randomName();
    $title = $this->randomName();

    // Add alt and title fields to the image file type.
    //_create_file_alt_title_fields();

    $field = array('field_name' => 'field_file_image_alt_text', 'type' => 'text');
    field_create_field($field);
    $instance = array(
      'field_name' => 'field_file_image_alt_text',
      'entity_type' => 'file',
      'bundle' => 'image',
      'label' => 'Alt',
    );
    field_create_instance($instance);

    $field = array('field_name' => 'field_file_image_title_text', 'type' => 'text');
    field_create_field($field);
    $instance = array(
      'field_name' => 'field_file_image_title_text',
      'entity_type' => 'file',
      'bundle' => 'image',
      'label' => 'Title',
    );
    field_create_instance($instance);

    // Upload a basic image file.
    $edit = array();
    $edit['files[upload]'] = backdrop_realpath($test_file->uri);
    $this->backdropPost('file/add', $edit, t('Next'));

    // Enter values into the attached fields.
    $edit = array();
    $edit['filename'] = $filename;
    $edit['field_file_image_alt_text[' . LANGUAGE_NONE . '][0][value]'] = $alt;
    $edit['field_file_image_title_text[' . LANGUAGE_NONE . '][0][value]'] = $title;
    $this->backdropPost(NULL, $edit, t('Save'));

    // Check that the image file has been uploaded.
    $this->assertRaw(t('@type %name was uploaded.', array('@type' => 'Image', '%name' => $filename)), t('Image file uploaded.'));

    // Check that the file exists in the database.
    $fid = $this->getLastFileId();
    $file = file_load($fid);
    $this->assertTrue($file, t('File found in database.'));

    // Check that the alt and title text was loaded from the fields.
    $alt_value = $file->field_file_image_alt_text['und'][0]['value'];
    $this->assertEqual($alt_value, $alt, t('Alt text was stored as field data.'));
    $title_value = $file->field_file_image_title_text['und'][0]['value'];
    $this->assertEqual($title_value, $title, t('Title text was stored as field data.'));
  }

  /**
   * Test skipping each of the file upload wizard steps.
   */
  function testFileUploadWizardStepSkipping() {
    $test_file = $this->getTestFile('image');
    $filename = $this->randomName();

    // Ensure that the file is affected by every step.
    config_set('system.core', 'file_private_path', $this->private_files_directory);

    $this->createFileType(array('type' => 'image1', 'name' => 'Image 1', 'mimetypes' => array('image/jpeg', 'image/gif', 'image/png', 'image/tiff')));
    $this->createFileType(array('type' => 'image2', 'name' => 'Image 2', 'mimetypes' => array('image/jpeg', 'image/gif', 'image/png', 'image/tiff')));

    $field_name = backdrop_strtolower($this->randomName() . '_field_name');
    $field = array('field_name' => $field_name, 'type' => 'text');
    field_create_field($field);
    $instance = array(
      'field_name' => $field_name,
      'entity_type' => 'file',
      'bundle' => 'image2',
      'label' => $this->randomName() . '_label',
    );
    field_create_instance($instance);

    // Test skipping each upload wizard step.
    $debug_i = 0;
    foreach (array('types', 'schemes', 'fields') as $skipped_step) {
      // Step to skip.
      switch ($skipped_step) {
        case 'types':
          config_set('file.settings', 'upload_wizard_skip_file_type', TRUE);
          break;
        case 'schemes':
          config_set('file.settings', 'upload_wizard_skip_scheme', TRUE);
          break;
        case 'fields':
          config_set('file.settings', 'upload_wizard_skip_fields', TRUE);
          break;
      }

      // Step 0: Upload a basic image file.
      debug('Step 0: Upload a basic image file.');
      $edit = array();
      $edit['files[upload]'] = backdrop_realpath($test_file->uri);
      $this->backdropPost('file/add', $edit, t('Next'));

      $debug_i++;
      debug('Step ' . $debug_i . ': ' . $skipped_step);

      // Step 1: File type selection.
      if ($skipped_step != 'types') {
        debug('Step 1: File type selection.');
        $this->assertText('File type', 'Types step confirmed.');
        $edit = array();
        $edit['type'] = 'image2';
        $this->backdropPost(NULL, $edit, t('Next'));
      }
      else {
        debug('Skipping types');
      }

      // Step 2: Scheme selection.
      if ($skipped_step != 'schemes') {
        debug('Step 2: Scheme selection.');
        $this->assertText('Private local files', 'Schemes step confirmed.');
        $edit = array();
        $edit['scheme'] = 'private';
        $this->backdropPost(NULL, $edit, t('Next'));
      }
      else {
        debug('Skipping schemes');
      }

      // Step 3: Attached fields.
      if ($skipped_step != 'fields') {
        // Skipping file type selection essentially skips this step as well
        // because the file will not be assigned a type so no fields will be
        // available.
        if ($skipped_step != 'types') {
          debug('Step 3: Attached fields.');
          $this->assertText('Configure file fields', 'Fields step confirmed.');
          $edit = array();
          $edit['filename'] = $filename;
          $edit[$field_name . '[' . LANGUAGE_NONE . '][0][value]'] = $this->randomName();
          $this->backdropPost(NULL, $edit, t('Save'));
        }
      }
      else {
        debug('Skipping fields');
      }

      // Check that the file exists in the database.
      $fid = $this->getLastFileId();
      $file = file_load($fid);
      $this->assertTrue($file, t('File found in database.'));

      // Determine the file's file type.
      $type = file_type_load($file->type);
      // Check that the image file has been uploaded.
      $this->assertRaw(t('@type %name was uploaded.', array('@type' => $type->name, '%name' => $file->filename)), t('Image file uploaded.'));

      // Reset 'skip' variables.
      $config = config('file.settings');
      $config->set('upload_wizard_skip_file_type', FALSE);
      $config->set('upload_wizard_skip_scheme', FALSE);
      $config->set('upload_wizard_skip_fields', FALSE);
      $config->save();
    }
  }
}