<?php

/**

 *  @file

 *  This provides SimpleTests for the core file handling functionality.

 *  These include FileValidateTest and FileSaveTest.

 */

/**

 * Helper validator that returns the $errors parameter.

 */

function file_test_validator($file, $errors) {

  return $errors;

}

/**

 * Helper function for testing file_scan_directory().

 *

 * Each time the function is called the file is stored in a static variable.

 * When the function is called with no $filepath parameter, the results are

 * returned.

 *

 * @param $filepath

 *   File path

 * @return

 *   If $filepath is NULL, an array of all previous $filepath parameters

 */

function file_test_file_scan_callback($filepath = NULL) {

  $files = &drupal_static(__FUNCTION__, array());

  if (isset($filepath)) {

    $files[] = $filepath;

  }

  else {

    return $files;

  }

}

/**

 * Reset static variables used by file_test_file_scan_callback().

 */

function file_test_file_scan_callback_reset() {

  drupal_static_reset('file_test_file_scan_callback');

}

/**

 * Base class for file tests that adds some additional file specific

 * assertions and helper functions.

 */

class FileTestCase extends DrupalWebTestCase {

  /**

   * Check that two files have the same values for all fields other than the

   * timestamp.

   *

   * @param $before

   *   File object to compare.

   * @param $after

   *   File object to compare.

   */

  function assertFileUnchanged($before, $after) {

    $this->assertEqual($before->fid, $after->fid, format_string('File id is the same: %file1 == %file2.', array('%file1' => $before->fid, '%file2' => $after->fid)), 'File unchanged');

    $this->assertEqual($before->uid, $after->uid, format_string('File owner is the same: %file1 == %file2.', array('%file1' => $before->uid, '%file2' => $after->uid)), 'File unchanged');

    $this->assertEqual($before->filename, $after->filename, format_string('File name is the same: %file1 == %file2.', array('%file1' => $before->filename, '%file2' => $after->filename)), 'File unchanged');

    $this->assertEqual($before->uri, $after->uri, format_string('File path is the same: %file1 == %file2.', array('%file1' => $before->uri, '%file2' => $after->uri)), 'File unchanged');

    $this->assertEqual($before->filemime, $after->filemime, format_string('File MIME type is the same: %file1 == %file2.', array('%file1' => $before->filemime, '%file2' => $after->filemime)), 'File unchanged');

    $this->assertEqual($before->filesize, $after->filesize, format_string('File size is the same: %file1 == %file2.', array('%file1' => $before->filesize, '%file2' => $after->filesize)), 'File unchanged');

    $this->assertEqual($before->status, $after->status, format_string('File status is the same: %file1 == %file2.', array('%file1' => $before->status, '%file2' => $after->status)), 'File unchanged');

  }

  /**

   * Check that two files are not the same by comparing the fid and filepath.

   *

   * @param $file1

   *   File object to compare.

   * @param $file2

   *   File object to compare.

   */

  function assertDifferentFile($file1, $file2) {

    $this->assertNotEqual($file1->fid, $file2->fid, format_string('Files have different ids: %file1 != %file2.', array('%file1' => $file1->fid, '%file2' => $file2->fid)), 'Different file');

    $this->assertNotEqual($file1->uri, $file2->uri, format_string('Files have different paths: %file1 != %file2.', array('%file1' => $file1->uri, '%file2' => $file2->uri)), 'Different file');

  }

  /**

   * Check that two files are the same by comparing the fid and filepath.

   *

   * @param $file1

   *   File object to compare.

   * @param $file2

   *   File object to compare.

   */

  function assertSameFile($file1, $file2) {

    $this->assertEqual($file1->fid, $file2->fid, format_string('Files have the same ids: %file1 == %file2.', array('%file1' => $file1->fid, '%file2-fid' => $file2->fid)), 'Same file');

    $this->assertEqual($file1->uri, $file2->uri, format_string('Files have the same path: %file1 == %file2.', array('%file1' => $file1->uri, '%file2' => $file2->uri)), 'Same file');

  }

  /**

   * Helper function to test the permissions of a file.

   *

   * @param $filepath

   *   String file path.

   * @param $expected_mode

   *   Octal integer like 0664 or 0777.

   * @param $message

   *   Optional message.

   */

  function assertFilePermissions($filepath, $expected_mode, $message = NULL) {

    // Clear out PHP's file stat cache to be sure we see the current value.

    clearstatcache();

    // Mask out all but the last three octets.

    $actual_mode = fileperms($filepath) & 0777;

    // PHP on Windows has limited support for file permissions. Usually each of

    // "user", "group" and "other" use one octal digit (3 bits) to represent the

    // read/write/execute bits. On Windows, chmod() ignores the "group" and

    // "other" bits, and fileperms() returns the "user" bits in all three

    // positions. $expected_mode is updated to reflect this.

    if (substr(PHP_OS, 0, 3) == 'WIN') {

      // Reset the "group" and "other" bits.

      $expected_mode = $expected_mode & 0700;

      // Shift the "user" bits to the "group" and "other" positions also.

      $expected_mode = $expected_mode | $expected_mode >> 3 | $expected_mode >> 6;

    }

    if (!isset($message)) {

      $message = t('Expected file permission to be %expected, actually were %actual.', array('%actual' => decoct($actual_mode), '%expected' => decoct($expected_mode)));

    }

    $this->assertEqual($actual_mode, $expected_mode, $message);

  }

  /**

   * Helper function to test the permissions of a directory.

   *

   * @param $directory

   *   String directory path.

   * @param $expected_mode

   *   Octal integer like 0664 or 0777.

   * @param $message

   *   Optional message.

   */

  function assertDirectoryPermissions($directory, $expected_mode, $message = NULL) {

    // Clear out PHP's file stat cache to be sure we see the current value.

    clearstatcache();

    // Mask out all but the last three octets.

    $actual_mode = fileperms($directory) & 0777;

    // PHP on Windows has limited support for file permissions. Usually each of

    // "user", "group" and "other" use one octal digit (3 bits) to represent the

    // read/write/execute bits. On Windows, chmod() ignores the "group" and

    // "other" bits, and fileperms() returns the "user" bits in all three

    // positions. $expected_mode is updated to reflect this.

    if (substr(PHP_OS, 0, 3) == 'WIN') {

      // Reset the "group" and "other" bits.

      $expected_mode = $expected_mode & 0700;

      // Shift the "user" bits to the "group" and "other" positions also.

      $expected_mode = $expected_mode | $expected_mode >> 3 | $expected_mode >> 6;

    }

    if (!isset($message)) {

      $message = t('Expected directory permission to be %expected, actually were %actual.', array('%actual' => decoct($actual_mode), '%expected' => decoct($expected_mode)));

    }

    $this->assertEqual($actual_mode, $expected_mode, $message);

  }

  /**

   * Create a directory and assert it exists.

   *

   * @param $path

   *   Optional string with a directory path. If none is provided, a random

   *   name in the site's files directory will be used.

   * @return

   *   The path to the directory.

   */

  function createDirectory($path = NULL) {

    // A directory to operate on.

    if (!isset($path)) {

      $path = file_default_scheme() . '://' . $this->randomName();

    }

    $this->assertTrue(drupal_mkdir($path) && is_dir($path), 'Directory was created successfully.');

    return $path;

  }

  /**

   * Create a file and save it to the files table and assert that it occurs

   * correctly.

   *

   * @param $filepath

   *   Optional string specifying the file path. If none is provided then a

   *   randomly named file will be created in the site's files directory.

   * @param $contents

   *   Optional contents to save into the file. If a NULL value is provided an

   *   arbitrary string will be used.

   * @param $scheme

   *   Optional string indicating the stream scheme to use. Drupal core includes

   *   public, private, and temporary. The public wrapper is the default.

   * @return

   *   File object.

   */

  function createFile($filepath = NULL, $contents = NULL, $scheme = NULL) {

    if (!isset($filepath)) {

      // Prefix with non-latin characters to ensure that all file-related

      // tests work with international filenames.

      $filepath = 'Файл для тестирования ' . $this->randomName();

    }

    if (!isset($scheme)) {

      $scheme = file_default_scheme();

    }

    $filepath = $scheme . '://' . $filepath;

    if (!isset($contents)) {

      $contents = "file_put_contents() doesn't seem to appreciate empty strings so let's put in some data.";

    }

    file_put_contents($filepath, $contents);

    $this->assertTrue(is_file($filepath), 'The test file exists on the disk.', 'Create test file');

    $file = new stdClass();

    $file->uri = $filepath;

    $file->filename = drupal_basename($file->uri);

    $file->filemime = 'text/plain';

    $file->uid = 1;

    $file->timestamp = REQUEST_TIME;

    $file->filesize = filesize($file->uri);

    $file->status = 0;

    // Write the record directly rather than calling file_save() so we don't

    // invoke the hooks.

    $this->assertNotIdentical(drupal_write_record('file_managed', $file), FALSE, 'The file was added to the database.', 'Create test file');

    return $file;

  }

}

/**

 * Base class for file tests that use the file_test module to test uploads and

 * hooks.

 */

class FileHookTestCase extends FileTestCase {

  function setUp() {

    // Install file_test module

    parent::setUp('file_test');

    // Clear out any hook calls.

    file_test_reset();

  }

  /**

   * Assert that all of the specified hook_file_* hooks were called once, other

   * values result in failure.

   *

   * @param $expected

   *   Array with string containing with the hook name, e.g. 'load', 'save',

   *   'insert', etc.

   */

  function assertFileHooksCalled($expected) {

    // Determine which hooks were called.

    $actual = array_keys(array_filter(file_test_get_all_calls()));

    // Determine if there were any expected that were not called.

    $uncalled = array_diff($expected, $actual);

    if (count($uncalled)) {

      $this->assertTrue(FALSE, format_string('Expected hooks %expected to be called but %uncalled was not called.', array('%expected' => implode(', ', $expected), '%uncalled' => implode(', ', $uncalled))));

    }

    else {

      $this->assertTrue(TRUE, format_string('All the expected hooks were called: %expected', array('%expected' => empty($expected) ? t('(none)') : implode(', ', $expected))));

    }

    // Determine if there were any unexpected calls.

    $unexpected = array_diff($actual, $expected);

    if (count($unexpected)) {

      $this->assertTrue(FALSE, format_string('Unexpected hooks were called: %unexpected.', array('%unexpected' => empty($unexpected) ? t('(none)') : implode(', ', $unexpected))));

    }

    else {

      $this->assertTrue(TRUE, 'No unexpected hooks were called.');

    }

  }

  /**

   * Assert that a hook_file_* hook was called a certain number of times.

   *

   * @param $hook

   *   String with the hook name, e.g. 'load', 'save', 'insert', etc.

   * @param $expected_count

   *   Optional integer count.

   * @param $message

   *   Optional translated string message.

   */

  function assertFileHookCalled($hook, $expected_count = 1, $message = NULL) {

    $actual_count = count(file_test_get_calls($hook));

    if (!isset($message)) {

      if ($actual_count == $expected_count) {

        $message = format_string('hook_file_@name was called correctly.', array('@name' => $hook));

      }

      elseif ($expected_count == 0) {

        $message = format_plural($actual_count, 'hook_file_@name was not expected to be called but was actually called once.', 'hook_file_@name was not expected to be called but was actually called @count times.', array('@name' => $hook, '@count' => $actual_count));

      }

      else {

        $message = format_string('hook_file_@name was expected to be called %expected times but was called %actual times.', array('@name' => $hook, '%expected' => $expected_count, '%actual' => $actual_count));

      }

    }

    $this->assertEqual($actual_count, $expected_count, $message);

  }

}

/**

 *  This will run tests against the file_space_used() function.

 */

class FileSpaceUsedTest extends FileTestCase {

  public static function getInfo() {

    return array(

      'name' => 'File space used tests',

      'description' => 'Tests the file_space_used() function.',

      'group' => 'File API',

    );

  }

  function setUp() {

    parent::setUp();

    // Create records for a couple of users with different sizes.

    $file = array('uid' => 2, 'uri' => 'public://example1.txt', 'filesize' => 50, 'status' => FILE_STATUS_PERMANENT);

    drupal_write_record('file_managed', $file);

    $file = array('uid' => 2, 'uri' => 'public://example2.txt', 'filesize' => 20, 'status' => FILE_STATUS_PERMANENT);

    drupal_write_record('file_managed', $file);

    $file = array('uid' => 3, 'uri' => 'public://example3.txt', 'filesize' => 100, 'status' => FILE_STATUS_PERMANENT);

    drupal_write_record('file_managed', $file);

    $file = array('uid' => 3, 'uri' => 'public://example4.txt', 'filesize' => 200, 'status' => FILE_STATUS_PERMANENT);

    drupal_write_record('file_managed', $file);

    // Now create some non-permanent files.

    $file = array('uid' => 2, 'uri' => 'public://example5.txt', 'filesize' => 1, 'status' => 0);

    drupal_write_record('file_managed', $file);

    $file = array('uid' => 3, 'uri' => 'public://example6.txt', 'filesize' => 3, 'status' => 0);

    drupal_write_record('file_managed', $file);

  }

  /**

   * Test different users with the default status.

   */

  function testFileSpaceUsed() {

    // Test different users with default status.

    $this->assertEqual(file_space_used(2), 70);

    $this->assertEqual(file_space_used(3), 300);

    $this->assertEqual(file_space_used(), 370);

    // Test the status fields

    $this->assertEqual(file_space_used(NULL, 0), 4);

    $this->assertEqual(file_space_used(NULL, FILE_STATUS_PERMANENT), 370);

    // Test both the user and status.

    $this->assertEqual(file_space_used(1, 0), 0);

    $this->assertEqual(file_space_used(1, FILE_STATUS_PERMANENT), 0);

    $this->assertEqual(file_space_used(2, 0), 1);

    $this->assertEqual(file_space_used(2, FILE_STATUS_PERMANENT), 70);

    $this->assertEqual(file_space_used(3, 0), 3);

    $this->assertEqual(file_space_used(3, FILE_STATUS_PERMANENT), 300);

  }

}

/**

 *  This will run tests against the file validation functions (file_validate_*).

 */

class FileValidatorTest extends DrupalWebTestCase {

  public static function getInfo() {

    return array(

      'name' => 'File validator tests',

      'description' => 'Tests the functions used to validate uploaded files.',

      'group' => 'File API',

    );

  }

  function setUp() {

    parent::setUp();

    $this->image = new stdClass();

    $this->image->uri = 'misc/druplicon.png';

    $this->image->filename = drupal_basename($this->image->uri);

    $this->non_image = new stdClass();

    $this->non_image->uri = 'misc/jquery.js';

    $this->non_image->filename = drupal_basename($this->non_image->uri);

  }

  /**

   * Test the file_validate_extensions() function.

   */

  function testFileValidateExtensions() {

    $file = new stdClass();

    $file->filename = 'asdf.txt';

    $errors = file_validate_extensions($file, 'asdf txt pork');

    $this->assertEqual(count($errors), 0, 'Valid extension accepted.', 'File');

    $file->filename = 'asdf.txt';

    $errors = file_validate_extensions($file, 'exe png');

    $this->assertEqual(count($errors), 1, 'Invalid extension blocked.', 'File');

  }

  /**

   *  This ensures a specific file is actually an image.

   */

  function testFileValidateIsImage() {

    $this->assertTrue(file_exists($this->image->uri), 'The image being tested exists.', 'File');

    $errors = file_validate_is_image($this->image);

    $this->assertEqual(count($errors), 0, 'No error reported for our image file.', 'File');

    $this->assertTrue(file_exists($this->non_image->uri), 'The non-image being tested exists.', 'File');

    $errors = file_validate_is_image($this->non_image);

    $this->assertEqual(count($errors), 1, 'An error reported for our non-image file.', 'File');

  }

  /**

   *  This ensures the resolution of a specific file is within bounds.

   *  The image will be resized if it's too large.

   */

  function testFileValidateImageResolution() {

    // Non-images.

    $errors = file_validate_image_resolution($this->non_image);

    $this->assertEqual(count($errors), 0, 'Should not get any errors for a non-image file.', 'File');

    $errors = file_validate_image_resolution($this->non_image, '50x50', '100x100');

    $this->assertEqual(count($errors), 0, 'Do not check the resolution on non files.', 'File');

    // Minimum size.

    $errors = file_validate_image_resolution($this->image);

    $this->assertEqual(count($errors), 0, 'No errors for an image when there is no minimum or maximum resolution.', 'File');

    $errors = file_validate_image_resolution($this->image, 0, '200x1');

    $this->assertEqual(count($errors), 1, 'Got an error for an image that was not wide enough.', 'File');

    $errors = file_validate_image_resolution($this->image, 0, '1x200');

    $this->assertEqual(count($errors), 1, 'Got an error for an image that was not tall enough.', 'File');

    $errors = file_validate_image_resolution($this->image, 0, '200x200');

    $this->assertEqual(count($errors), 1, 'Small images report an error.', 'File');

    // Maximum size.

    if (image_get_toolkit()) {

      // Copy the image so that the original doesn't get resized.

      copy('misc/druplicon.png', 'temporary://druplicon.png');

      $this->image->uri = 'temporary://druplicon.png';

      $errors = file_validate_image_resolution($this->image, '10x5');

      $this->assertEqual(count($errors), 0, 'No errors should be reported when an oversized image can be scaled down.', 'File');

      $info = image_get_info($this->image->uri);

      $this->assertTrue($info['width'] <= 10, 'Image scaled to correct width.', 'File');

      $this->assertTrue($info['height'] <= 5, 'Image scaled to correct height.', 'File');

      drupal_unlink('temporary://druplicon.png');

    }

    else {

      // TODO: should check that the error is returned if no toolkit is available.

      $errors = file_validate_image_resolution($this->image, '5x10');

      $this->assertEqual(count($errors), 1, 'Oversize images that cannot be scaled get an error.', 'File');

    }

  }

  /**

   *  This will ensure the filename length is valid.

   */

  function testFileValidateNameLength() {

    // Create a new file object.

    $file = new stdClass();

    // Add a filename with an allowed length and test it.

    $file->filename = str_repeat('x', 240);

    $this->assertEqual(strlen($file->filename), 240);

    $errors = file_validate_name_length($file);

    $this->assertEqual(count($errors), 0, 'No errors reported for 240 length filename.', 'File');

    // Add a filename with a length too long and test it.

    $file->filename = str_repeat('x', 241);

    $errors = file_validate_name_length($file);

    $this->assertEqual(count($errors), 1, 'An error reported for 241 length filename.', 'File');

    // Add a filename with an empty string and test it.

    $file->filename = '';

    $errors = file_validate_name_length($file);

    $this->assertEqual(count($errors), 1, 'An error reported for 0 length filename.', 'File');

  }

  /**

   * Test file_validate_size().

   */

  function testFileValidateSize() {

    // Create a file with a size of 1000 bytes, and quotas of only 1 byte.

    $file = new stdClass();

    $file->filesize = 1000;

    $errors = file_validate_size($file, 0, 0);

    $this->assertEqual(count($errors), 0, 'No limits means no errors.', 'File');

    $errors = file_validate_size($file, 1, 0);

    $this->assertEqual(count($errors), 1, 'Error for the file being over the limit.', 'File');

    $errors = file_validate_size($file, 0, 1);

    $this->assertEqual(count($errors), 1, 'Error for the user being over their limit.', 'File');

    $errors = file_validate_size($file, 1, 1);

    $this->assertEqual(count($errors), 2, 'Errors for both the file and their limit.', 'File');

  }

}

/**

 *  Tests the file_unmanaged_save_data() function.

 */

class FileUnmanagedSaveDataTest extends FileTestCase {

  public static function getInfo() {

    return array(

      'name' => 'Unmanaged file save data',

      'description' => 'Tests the unmanaged file save data function.',

      'group' => 'File API',

    );

  }

  /**

   * Test the file_unmanaged_save_data() function.

   */

  function testFileSaveData() {

    $contents = $this->randomName(8);

    // No filename.

    $filepath = file_unmanaged_save_data($contents);

    $this->assertTrue($filepath, 'Unnamed file saved correctly.');

    $this->assertEqual(file_uri_scheme($filepath), file_default_scheme(), "File was placed in Drupal's files directory.");

    $this->assertEqual($contents, file_get_contents($filepath), 'Contents of the file are correct.');

    // Provide a filename.

    $filepath = file_unmanaged_save_data($contents, 'public://asdf.txt', FILE_EXISTS_REPLACE);

    $this->assertTrue($filepath, 'Unnamed file saved correctly.');

    $this->assertEqual('asdf.txt', drupal_basename($filepath), 'File was named correctly.');

    $this->assertEqual($contents, file_get_contents($filepath), 'Contents of the file are correct.');

    $this->assertFilePermissions($filepath, variable_get('file_chmod_file', 0664));

  }