Update to Drupal 8.0.0-beta15. For more information, see: https://www.drupal.org/node/2563023

core/modules/file/src/Tests/FileFieldDisplayTest.php

@@ -50,6 +50,12 @@ class FileFieldDisplayTest extends FileFieldTestBase {
     }
 
     $test_file = $this->getTestFile('text');
+    simpletest_generate_file('escaped-&-text', 64, 10, 'text');
+    $test_file = File::create([
+      'uri' => 'public://escaped-&-text.txt',
+      'name' => 'escaped-&-text',
+      'filesize' => filesize('public://escaped-&-text.txt'),
+    ]);
 
     // Create a new node with the uploaded file.
     $nid = $this->uploadNodeFile($test_file, $field_name, $type_name);
@@ -81,6 +87,9 @@ class FileFieldDisplayTest extends FileFieldTestBase {
     $this->drupalPostForm('node/' . $nid . '/edit', $edit, t('Save and keep published'));
     $this->assertText($description);
 
+    // Ensure the filename in the link's title attribute is escaped.
+    $this->assertRaw('title="escaped-&-text.txt"');
+
     // Test that fields appear as expected after during the preview.
     // Add a second file.
     $name = 'files[' . $field_name . '_1][]';

core/modules/file/src/Tests/FileFieldValidateTest.php

@@ -35,7 +35,7 @@ class FileFieldValidateTest extends FileFieldTestBase {
     $edit = array();
     $edit['title[0][value]'] = $this->randomMachineName();
     $this->drupalPostForm('node/add/' . $type_name, $edit, t('Save and publish'));
-    $this->assertText('1 error has been found: ' . $field->label(), 'Node save failed when required file field was empty.');
+    $this->assertText('1 error has been found:   ' . $field->label(), 'Node save failed when required file field was empty.');
     $this->assertIdentical(1, count($this->xpath('//div[contains(concat(" ", normalize-space(@class), " "), :class)]//a', [':class' => ' messages--error '])), 'There is one link in the error message.');
 
     // Create a new node with the uploaded file.
@@ -57,7 +57,7 @@ class FileFieldValidateTest extends FileFieldTestBase {
     $edit = array();
     $edit['title[0][value]'] = $this->randomMachineName();
     $this->drupalPostForm('node/add/' . $type_name, $edit, t('Save and publish'));
-    $this->assertText('1 error has been found: '  . $field->label(), 'Node save failed when required multiple value file field was empty.');
+    $this->assertText('1 error has been found:   '  . $field->label(), 'Node save failed when required multiple value file field was empty.');
     $this->assertIdentical(1, count($this->xpath('//div[contains(concat(" ", normalize-space(@class), " "), :class)]//a', [':class' => ' messages--error '])), 'There is one link in the error message.');
 
     // Create a new node with the uploaded file into the multivalue field.

core/modules/file/src/Tests/FileFieldWidgetTest.php

@@ -9,7 +9,9 @@ namespace Drupal\file\Tests;
 
 use Drupal\comment\Entity\Comment;
 use Drupal\comment\Tests\CommentTestTrait;
+use Drupal\Component\Utility\Unicode;
 use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
 use Drupal\field_ui\Tests\FieldUiTestTrait;
 use Drupal\user\RoleInterface;
 use Drupal\file\Entity\File;
@@ -419,4 +421,32 @@ class FileFieldWidgetTest extends FileFieldTestBase {
       $this->assertNoRaw($error_message, t('Validation error removed when file with correct extension uploaded (JSMode=%type).', array('%type' => $type)));
     }
   }
+
+  /**
+   * Tests file widget element.
+   */
+  public function testWidgetElement() {
+    $field_name = Unicode::strtolower($this->randomMachineName());
+    $html_name = str_replace('_', '-', $field_name);
+    $this->createFileField($field_name, 'node', 'article', ['cardinality' => FieldStorageConfig::CARDINALITY_UNLIMITED]);
+    $file = $this->getTestFile('text');
+    $xpath = "//details[@data-drupal-selector='edit-$html_name']/div[@class='details-wrapper']/table";
+
+    $this->drupalGet('node/add/article');
+
+    $elements = $this->xpath($xpath);
+
+    // If the field has no item, the table should not be visible.
+    $this->assertIdentical(count($elements), 0);
+
+    // Upload a file.
+    $edit['files[' . $field_name . '_0][]'] = $this->container->get('file_system')->realpath($file->getFileUri());
+    $this->drupalPostAjaxForm(NULL, $edit, "{$field_name}_0_upload_button");
+
+    $elements = $this->xpath($xpath);
+
+    // If the field has at least a item, the table should be visible.
+    $this->assertIdentical(count($elements), 1);
+  }
+
 }

core/modules/file/src/Tests/FileManagedAccessTest.php

@@ -0,0 +1,73 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\FileManagedAccessTest.
+ */
+
+namespace Drupal\file\Tests;
+
+use Drupal\file\Entity\File;
+
+/**
+ * Tests access to managed files.
+ *
+ * @group file
+ */
+class FileManagedAccessTest extends FileManagedTestBase {
+
+  /**
+   * Tests if public file is always accessible.
+   */
+  function testFileAccess() {
+    // Create a new file entity.
+    $file = File::create(array(
+      'uid' => 1,
+      'filename' => 'drupal.txt',
+      'uri' => 'public://drupal.txt',
+      'filemime' => 'text/plain',
+      'status' => FILE_STATUS_PERMANENT,
+    ));
+    file_put_contents($file->getFileUri(), 'hello world');
+
+    // Save it, inserting a new record.
+    $file->save();
+
+    // Create authenticated user to check file access.
+    $account = $this->createUser(array('access site reports'));
+
+    $this->assertTrue($file->access('view', $account), 'Public file is viewable to authenticated user');
+    $this->assertTrue($file->access('download', $account), 'Public file is downloadable to authenticated user');
+
+    // Create anonymous user to check file access.
+    $account = $this->createUser()->getAnonymousUser();
+
+    $this->assertTrue($file->access('view', $account), 'Public file is viewable to anonymous user');
+    $this->assertTrue($file->access('download', $account), 'Public file is downloadable to anonymous user');
+
+    // Create a new file entity.
+    $file = File::create(array(
+      'uid' => 1,
+      'filename' => 'drupal.txt',
+      'uri' => 'private://drupal.txt',
+      'filemime' => 'text/plain',
+      'status' => FILE_STATUS_PERMANENT,
+    ));
+    file_put_contents($file->getFileUri(), 'hello world');
+
+    // Save it, inserting a new record.
+    $file->save();
+
+    // Create authenticated user to check file access.
+    $account = $this->createUser(array('access site reports'));
+
+    $this->assertFalse($file->access('view', $account), 'Private file is not viewable to authenticated user');
+    $this->assertFalse($file->access('download', $account), 'Private file is not downloadable to authenticated user');
+
+    // Create anonymous user to check file access.
+    $account = $this->createUser()->getAnonymousUser();
+
+    $this->assertFalse($file->access('view', $account), 'Private file is not viewable to anonymous user');
+    $this->assertFalse($file->access('download', $account), 'Private file is not downloadable to anonymous user');
+  }
+}

core/modules/file/src/Tests/FileManagedFileElementTest.php

@@ -37,6 +37,18 @@ class FileManagedFileElementTest extends FileFieldTestBase {
           $this->drupalPostForm($path, array(), t('Save'));
           $this->assertRaw(t('The file ids are %fids.', array('%fids' => implode(',', array()))), 'Submitted without a file.');
 
+          // Submit with a file, but with an invalid form token. Ensure the file
+          // was not saved.
+          $last_fid_prior = $this->getLastFileId();
+          $edit = [
+            $file_field_name => drupal_realpath($test_file->getFileUri()),
+            'form_token' => 'invalid token',
+          ];
+          $this->drupalPostForm($path, $edit, t('Save'));
+          $this->assertText('The form has become outdated. Copy any unsaved work in the form below');
+          $last_fid = $this->getLastFileId();
+          $this->assertEqual($last_fid_prior, $last_fid, 'File was not saved when uploaded with an invalid form token.');
+
           // Submit a new file, without using the Upload button.
           $last_fid_prior = $this->getLastFileId();
           $edit = array($file_field_name => drupal_realpath($test_file->getFileUri()));

core/modules/file/src/Tests/FileTokenReplaceTest.php

@@ -7,7 +7,7 @@
 
 namespace Drupal\file\Tests;
 
-use Drupal\Component\Utility\SafeMarkup;
+use Drupal\Component\Utility\Html;
 use Drupal\Core\Render\BubbleableMetadata;
 use Drupal\file\Entity\File;
 
@@ -47,16 +47,16 @@ class FileTokenReplaceTest extends FileFieldTestBase {
     // Generate and test sanitized tokens.
     $tests = array();
     $tests['[file:fid]'] = $file->id();
-    $tests['[file:name]'] = SafeMarkup::checkPlain($file->getFilename());
-    $tests['[file:path]'] = SafeMarkup::checkPlain($file->getFileUri());
-    $tests['[file:mime]'] = SafeMarkup::checkPlain($file->getMimeType());
+    $tests['[file:name]'] = Html::escape($file->getFilename());
+    $tests['[file:path]'] = Html::escape($file->getFileUri());
+    $tests['[file:mime]'] = Html::escape($file->getMimeType());
     $tests['[file:size]'] = format_size($file->getSize());
-    $tests['[file:url]'] = SafeMarkup::checkPlain(file_create_url($file->getFileUri()));
+    $tests['[file:url]'] = Html::escape(file_create_url($file->getFileUri()));
     $tests['[file:created]'] = format_date($file->getCreatedTime(), 'medium', '', NULL, $language_interface->getId());
     $tests['[file:created:short]'] = format_date($file->getCreatedTime(), 'short', '', NULL, $language_interface->getId());
     $tests['[file:changed]'] = format_date($file->getChangedTime(), 'medium', '', NULL, $language_interface->getId());
     $tests['[file:changed:short]'] = format_date($file->getChangedTime(), 'short', '', NULL, $language_interface->getId());
-    $tests['[file:owner]'] = SafeMarkup::checkPlain(user_format_name($this->adminUser));
+    $tests['[file:owner]'] = Html::escape(user_format_name($this->adminUser));
     $tests['[file:owner:uid]'] = $file->getOwnerId();
 
     $base_bubbleable_metadata = BubbleableMetadata::createFromObject($file);

core/modules/file/src/Tests/Migrate/EntityFileTest.php

@@ -0,0 +1,295 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\EntityFileTest.
+ */
+
+namespace Drupal\file\Tests\Migrate;
+
+use Drupal\Core\Site\Settings;
+use Drupal\migrate\Row;
+use Drupal\file\Plugin\migrate\destination\EntityFile;
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\entity_test\Entity\EntityTest;
+use Drupal\migrate\MigrateException;
+use Drupal\simpletest\KernelTestBase;
+
+/**
+ * Tests the entity file destination plugin.
+ *
+ * @group file
+ */
+class EntityFileTest extends KernelTestBase {
+
+  /**
+   * Modules to install.
+   *
+   * @var array
+   */
+  public static $modules = array('system', 'entity_test', 'user', 'file');
+
+  /**
+   * @var \Drupal\file\Tests\Migrate\TestEntityFile $destination
+   */
+  protected $destination;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    parent::setUp();
+    $this->destination = new TestEntityFile([]);
+    $this->destination->streamWrapperManager = \Drupal::getContainer()->get('stream_wrapper_manager');
+    $this->destination->fileSystem = \Drupal::getContainer()->get('file_system');
+    $this->installEntitySchema('file');
+
+    file_put_contents('/tmp/test-file.jpg', '');
+  }
+
+  /**
+   * Test successful imports/copies.
+   */
+  public function testSuccessfulCopies() {
+    foreach ($this->localFileDataProvider() as $data) {
+      list($row_values, $destination_path, $expected, $source_base_path) = $data;
+
+      $this->doImport($row_values, $destination_path, $source_base_path);
+      $message = $expected ? sprintf('File %s exists', $destination_path) : sprintf('File %s does not exist', $destination_path);
+      $this->assertIdentical($expected, is_file($destination_path), $message);
+    }
+  }
+
+  /**
+   * The data provider for testing the file destination.
+   *
+   * @return array
+   *   An array of file permutations to test.
+   */
+  protected function localFileDataProvider() {
+    global $base_url;
+    return [
+      // Test a local to local copy.
+      [['filepath' => 'core/modules/simpletest/files/image-test.jpg'], 'public://file1.jpg', TRUE, DRUPAL_ROOT . '/'],
+      // Test a temporary file using an absolute path.
+      [['filepath' => '/tmp/test-file.jpg'], 'temporary://test.jpg', TRUE, ''],
+      // Test a temporary file using a relative path.
+      [['filepath' => 'test-file.jpg'], 'temporary://core/modules/simpletest/files/test.jpg', TRUE, '/tmp/'],
+      // Test a remote path to local.
+      [['filepath' => 'core/modules/simpletest/files/image-test.jpg'], 'public://remote-file.jpg', TRUE, $base_url . '/'],
+      // Test a remote path to local inside a folder that doesn't exist.
+      [['filepath' => 'core/modules/simpletest/files/image-test.jpg'], 'public://folder/remote-file.jpg', TRUE, DRUPAL_ROOT . '/'],
+    ];
+  }
+
+  /**
+   * Test that non-existent files throw an exception.
+   */
+  public function testNonExistentSourceFile() {
+    $destination = '/non/existent/file';
+    try {
+      // If this test passes, doImport() will raise a MigrateException and
+      // we'll never reach fail().
+      $this->doImport(['filepath' => $destination], 'public://wontmatter.jpg');
+      $this->fail('Expected Drupal\migrate\MigrateException when importing ' . $destination);
+    }
+    catch (MigrateException $e) {
+      $this->assertIdentical($e->getMessage(), "File '$destination' does not exist.");
+    }
+  }
+
+  /**
+   * Tests various invocations of the writeFile() method.
+   */
+  public function testWriteFile() {
+    $plugin = $this->destination;
+    $method = new \ReflectionMethod($plugin, 'writeFile');
+    $method->setAccessible(TRUE);
+
+    touch('temporary://baz.txt');
+
+    // Moving an actual file should return TRUE.
+    $plugin->configuration['move'] = TRUE;
+    $this->assertTrue($method->invoke($plugin, 'temporary://baz.txt', 'public://foo.txt'));
+
+    // Trying to move a non-existent file should return FALSE.
+    $this->assertFalse($method->invoke($plugin, 'temporary://invalid.txt', 'public://invalid.txt'));
+
+    // Copying over a file that already exists should replace the existing file.
+    $plugin->configuration['move'] = FALSE;
+    touch('temporary://baz.txt');
+    $this->assertTrue($method->invoke($plugin, 'temporary://baz.txt', 'public://foo.txt'));
+    // Copying over a file that already exists should rename the resulting file
+    // if FILE_EXISTS_RENAME is specified.
+    $method->invoke($plugin, 'temporary://baz.txt', 'public://foo.txt', FILE_EXISTS_RENAME);
+    $this->assertTrue(file_exists('public://foo_0.txt'));
+
+    // Trying to copy a non-existent file should return FALSE.
+    $this->assertFalse($method->invoke($plugin, 'temporary://invalid.txt', 'public://invalid.txt'));
+  }
+
+  /**
+   * Tests various invocations of the getOverwriteMode() method.
+   */
+  public function testGetOverwriteMode() {
+    $plugin = $this->destination;
+    $method = new \ReflectionMethod($plugin, 'getOverwriteMode');
+    $method->setAccessible(TRUE);
+
+    $row = new Row([], []);
+    // If the plugin is not configured to rename the destination file, we should
+    // always get FILE_EXISTS_REPLACE.
+    $this->assertIdentical(FILE_EXISTS_REPLACE, $method->invoke($plugin, $row));
+
+    // When the plugin IS configured to rename the destination file, it should
+    // return FILE_EXISTS_RENAME if the destination entity already exists,
+    // and FILE_EXISTS_REPLACE otherwise.
+    $plugin->configuration['rename'] = TRUE;
+    $plugin->storage = \Drupal::entityManager()->getStorage('file');
+    /** @var \Drupal\file\FileInterface $file */
+    $file = $plugin->storage->create();
+    touch('public://foo.txt');
+    $file->setFileUri('public://foo.txt');
+    $file->save();
+    $row->setDestinationProperty($plugin->storage->getEntityType()->getKey('id'), $file->id());
+    $this->assertIdentical(FILE_EXISTS_RENAME, $method->invoke($plugin, $row));
+    unlink('public://foo.txt');
+  }
+
+  /**
+   * Tests various invocations of the getDirectory() method.
+   */
+  public function testGetDirectory() {
+    $plugin = $this->destination;
+    $method = new \ReflectionMethod($plugin, 'getDirectory');
+    $method->setAccessible(TRUE);
+
+    $this->assertEqual('public://foo', $method->invoke($plugin, 'public://foo/baz.txt'));
+    $this->assertEqual('/path/to', $method->invoke($plugin, '/path/to/foo.txt'));
+    // A directory like public:// (no path) needs to resolve to a physical path.
+    $fs = \Drupal::getContainer()->get('file_system');
+    $this->assertEqual($fs->realpath(Settings::get('file_public_path')), $method->invoke($plugin, 'public://foo.txt'));
+  }
+
+  /**
+   * Tests various invocations of the isLocationUnchanged() method.
+   */
+  public function testIsLocationUnchanged() {
+    $plugin = $this->destination;
+    $method = new \ReflectionMethod($plugin, 'isLocationUnchanged');
+    $method->setAccessible(TRUE);
+
+    $public_dir = Settings::get('file_public_path');
+
+    // Due to the limitations of realpath(), the source file must exist.
+    touch('public://foo.txt');
+    $this->assertTrue($method->invoke($plugin, $public_dir . '/foo.txt', 'public://foo.txt'));
+    unlink('public://foo.txt');
+
+    $temporary_file = '/tmp/foo.txt';
+    touch($temporary_file);
+    $this->assertTrue($method->invoke($plugin, $temporary_file, 'temporary://foo.txt'));
+    unlink($temporary_file);
+  }
+
+  /**
+   * Tests various invocations of the isLocalUri() method.
+   */
+  public function testIsLocalUri() {
+    $plugin = $this->destination;
+    $method = new \ReflectionMethod($plugin, 'isLocalUri');
+    $method->setAccessible(TRUE);
+
+    $this->assertTrue($method->invoke($plugin, 'public://foo.txt'));
+    $this->assertTrue($method->invoke($plugin, 'public://path/to/foo.txt'));
+    $this->assertTrue($method->invoke($plugin, 'temporary://foo.txt'));
+    $this->assertTrue($method->invoke($plugin, 'temporary://path/to/foo.txt'));
+    $this->assertTrue($method->invoke($plugin, 'foo.txt'));
+    $this->assertTrue($method->invoke($plugin, '/path/to/files/foo.txt'));
+    $this->assertTrue($method->invoke($plugin, 'relative/path/to/foo.txt'));
+    $this->assertFalse($method->invoke($plugin, 'http://www.example.com/foo.txt'));
+  }
+
+  /**
+   * Do an import using the destination.
+   *
+   * @param array $row_values
+   *   An array of row values.
+   * @param string $destination_path
+   *   The destination path to copy to.
+   * @param string $source_base_path
+   *   The source base path.
+   * @return array
+   *   An array of saved entities ids.
+   *
+   * @throws \Drupal\migrate\MigrateException
+   */
+  protected function doImport($row_values, $destination_path, $source_base_path = '') {
+    $row = new Row($row_values, []);
+    $row->setDestinationProperty('uri', $destination_path);
+    $this->destination->configuration['source_base_path'] = $source_base_path;
+
+    // Importing asserts there are no errors, then we just check the file has
+    // been copied into place.
+    return $this->destination->import($row, array());
+  }
+
+}
+
+class TestEntityFile extends EntityFile {
+
+  /**
+   * This is needed to be passed to $this->save().
+   *
+   * @var \Drupal\Core\Entity\ContentEntityInterface
+   */
+  public $mockEntity;
+
+  /**
+   * Make this public for easy writing during tests.
+   *
+   * @var array
+   */
+  public $configuration;
+
+  /**
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  public $storage;
+
+  /**
+   * @var \Drupal\Core\StreamWrapper\StreamWrapperManagerInterface
+   */
+  public $streamWrapperManager;
+
+  /**
+   * @var \Drupal\Core\File\FileSystemInterface
+   */
+  public $fileSystem;
+
+  public function __construct($configuration) {
+    $configuration +=  array(
+      'source_base_path' => '',
+      'source_path_property' => 'filepath',
+      'destination_path_property' => 'uri',
+      'move' => FALSE,
+      'urlencode' => FALSE,
+    );
+    $this->configuration = $configuration;
+    // We need a mock entity to be passed to save to prevent strict exceptions.
+    $this->mockEntity = EntityTest::create();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getEntity(Row $row, array $old_destination_id_values) {
+    return $this->mockEntity;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function save(ContentEntityInterface $entity, array $old_destination_id_values = array()) {}
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateFileConfigsTest.php

@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateFileConfigsTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\config\Tests\SchemaCheckTestTrait;
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+
+/**
+ * Upgrade variables to file.settings.yml.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateFileConfigsTest extends MigrateDrupal6TestBase {
+
+  use SchemaCheckTestTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('file');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->executeMigration('d6_file_settings');
+  }
+
+  /**
+   * Tests migration of file variables to file.settings.yml.
+   */
+  public function testFileSettings() {
+    $config = $this->config('file.settings');
+    $this->assertIdentical('textfield', $config->get('description.type'));
+    $this->assertIdentical(128, $config->get('description.length'));
+    $this->assertIdentical('sites/default/files/icons', $config->get('icon.directory'));
+    $this->assertConfigSchema(\Drupal::service('config.typed'), 'file.settings', $config->get());
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateFileTest.php

@@ -0,0 +1,130 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateFileTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\Component\Utility\Random;
+use Drupal\migrate\Tests\MigrateDumpAlterInterface;
+use Drupal\Core\Database\Database;
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+use Drupal\simpletest\TestBase;
+use Drupal\file\Entity\File;
+
+/**
+ * file migration.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateFileTest extends MigrateDrupal6TestBase implements MigrateDumpAlterInterface {
+
+  /**
+   * The filename of a file used to test temporary file migration.
+   *
+   * @var string
+   */
+  protected static $tempFilename;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('file');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->installEntitySchema('file');
+    $this->installConfig(['file']);
+
+    /** @var \Drupal\migrate\Entity\MigrationInterface $migration */
+    $migration = entity_load('migration', 'd6_file');
+    $source = $migration->get('source');
+    $source['site_path'] = 'core/modules/simpletest';
+    $migration->set('source', $source);
+    $this->executeMigration($migration);
+    $this->standalone = TRUE;
+  }
+
+  /**
+   * Tests the Drupal 6 files to Drupal 8 migration.
+   */
+  public function testFiles() {
+    /** @var \Drupal\file\FileInterface $file */
+    $file = File::load(1);
+    $this->assertIdentical('Image1.png', $file->getFilename());
+    $this->assertIdentical('39325', $file->getSize());
+    $this->assertIdentical('public://image-1.png', $file->getFileUri());
+    $this->assertIdentical('image/png', $file->getMimeType());
+    $this->assertIdentical("1", $file->getOwnerId());
+
+    // It is pointless to run the second half from MigrateDrupal6Test.
+    if (empty($this->standalone)) {
+      return;
+    }
+
+    // Test that we can re-import and also test with file_directory_path set.
+    db_truncate(entity_load('migration', 'd6_file')->getIdMap()->mapTableName())->execute();
+
+    // Update the file_directory_path.
+    Database::getConnection('default', 'migrate')
+      ->update('variable')
+      ->fields(array('value' => serialize('files/test')))
+      ->condition('name', 'file_directory_path')
+      ->execute();
+    Database::getConnection('default', 'migrate')
+      ->update('variable')
+      ->fields(array('value' => serialize($this->getTempFilesDirectory())))
+      ->condition('name', 'file_directory_temp')
+      ->execute();
+
+    $migration = entity_load_unchanged('migration', 'd6_file');
+    $this->executeMigration($migration);
+
+    $file = File::load(2);
+    $this->assertIdentical('public://core/modules/simpletest/files/image-2.jpg', $file->getFileUri());
+
+    // Ensure that a temporary file has been migrated.
+    $file = File::load(6);
+    $this->assertIdentical('temporary://' . static::getUniqueFilename(), $file->getFileUri());
+  }
+
+  /**
+   * @return string
+   *   A filename based upon the test.
+   */
+  public static function getUniqueFilename() {
+    return static::$tempFilename;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function migrateDumpAlter(TestBase $test) {
+    // Creates a random filename and updates the source database.
+    $random = new Random();
+    $temp_directory = $test->getTempFilesDirectory();
+    file_prepare_directory($temp_directory, FILE_CREATE_DIRECTORY);
+    static::$tempFilename = $test->getDatabasePrefix() . $random->name() . '.jpg';
+    $file_path = $temp_directory . '/' . static::$tempFilename;
+    file_put_contents($file_path, '');
+    Database::getConnection('default', 'migrate')
+      ->update('files')
+      ->condition('fid', 6)
+      ->fields(array(
+        'filename' => static::$tempFilename,
+        'filepath' => $file_path,
+      ))
+      ->execute();
+
+    return static::$tempFilename;
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateUploadBase.php

@@ -0,0 +1,100 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateUploadBase.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+
+/**
+ * Base class for file/upload migration tests.
+ */
+abstract class MigrateUploadBase extends MigrateDrupal6TestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  static $modules = array('file', 'node');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->installEntitySchema('file');
+    $this->installEntitySchema('node');
+    $this->installSchema('file', ['file_usage']);
+    $this->installSchema('node', ['node_access']);
+
+    // Create new file entities.
+    for ($i = 1; $i <= 3; $i++) {
+      $file = entity_create('file', array(
+        'fid' => $i,
+        'uid' => 1,
+        'filename' => 'druplicon.txt',
+        'uri' => "public://druplicon-$i.txt",
+        'filemime' => 'text/plain',
+        'created' => 1,
+        'changed' => 1,
+        'status' => FILE_STATUS_PERMANENT,
+      ));
+      $file->enforceIsNew();
+      file_put_contents($file->getFileUri(), 'hello world');
+
+      // Save it, inserting a new record.
+      $file->save();
+      $id_mappings['d6_file'][] = array(array($i), array($i));
+    }
+
+    // Add a node type.
+    $node_type = entity_create('node_type', array('type' => 'story'));
+    $node_type->save();
+
+    // Add a file field.
+    entity_create('field_storage_config', array(
+      'field_name' => 'upload',
+      'entity_type' => 'node',
+      'type' => 'file',
+      'cardinality' => -1,
+      'settings' => array(
+        'display_field' => TRUE,
+      ),
+    ))->save();
+    entity_create('field_config', array(
+      'field_name' => 'upload',
+      'entity_type' => 'node',
+      'bundle' => 'story',
+    ))->save();
+    $id_mappings['d6_node'] = array(
+      array(array(1), array(1)),
+      array(array(2), array(2)),
+    );
+    $id_mappings['d6_upload_field_instance'] = [
+      [['story'], ['node', 'story', 'upload']],
+    ];
+
+    $this->prepareMigrations($id_mappings);
+    $vids = array(1, 2, 3);
+    for ($i = 1; $i <= 2; $i++) {
+      $node = entity_create('node', array(
+        'type' => 'story',
+        'nid' => $i,
+        'vid' => array_shift($vids),
+        'title' => $this->randomString(),
+      ));
+      $node->enforceIsNew();
+      $node->save();
+      if ($i == 1) {
+        $node->vid->value = array_shift($vids);
+        $node->enforceIsNew(FALSE);
+        $node->isDefaultRevision(FALSE);
+        $node->save();
+      }
+    }
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateUploadEntityDisplayTest.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateUploadEntityDisplayTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+
+/**
+ * Upload entity display.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateUploadEntityDisplayTest extends MigrateDrupal6TestBase {
+
+  /**
+   * The modules to be enabled during the test.
+   *
+   * @var array
+   */
+  static $modules = array('node', 'file');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    entity_create('node_type', array('type' => 'article'))->save();
+    entity_create('node_type', array('type' => 'story'))->save();
+    entity_create('node_type', array('type' => 'page'))->save();
+
+    $id_mappings = array(
+      'd6_upload_field_instance' => array(
+        array(array(1), array('node', 'page', 'upload')),
+      ),
+    );
+    $this->prepareMigrations($id_mappings);
+    $this->executeMigration('d6_upload_entity_display');
+  }
+
+  /**
+   * Tests the Drupal 6 upload settings to Drupal 8 entity display migration.
+   */
+  public function testUploadEntityDisplay() {
+    $display = entity_get_display('node', 'page', 'default');
+    $component = $display->getComponent('upload');
+    $this->assertIdentical('file_default', $component['type']);
+
+    $display = entity_get_display('node', 'story', 'default');
+    $component = $display->getComponent('upload');
+    $this->assertIdentical('file_default', $component['type']);
+
+    // Assure this doesn't exist.
+    $display = entity_get_display('node', 'article', 'default');
+    $component = $display->getComponent('upload');
+    $this->assertTrue(is_null($component));
+
+    $this->assertIdentical(array('node', 'page', 'default', 'upload'), entity_load('migration', 'd6_upload_entity_display')->getIdMap()->lookupDestinationID(array('page')));
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateUploadEntityFormDisplayTest.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateUploadEntityFormDisplayTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+
+/**
+ * Upload form entity display.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateUploadEntityFormDisplayTest extends MigrateDrupal6TestBase {
+
+  /**
+   * The modules to be enabled during the test.
+   *
+   * @var array
+   */
+  static $modules = array('file', 'node');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    entity_create('node_type', array('type' => 'article'))->save();
+    entity_create('node_type', array('type' => 'story'))->save();
+    entity_create('node_type', array('type' => 'page'))->save();
+
+    $id_mappings = array(
+      'd6_upload_field_instance' => array(
+        array(array(1), array('node', 'page', 'upload')),
+      ),
+    );
+    $this->prepareMigrations($id_mappings);
+    $this->executeMigration('d6_upload_entity_form_display');
+  }
+
+  /**
+   * Tests the Drupal 6 upload settings to Drupal 8 entity form display migration.
+   */
+  public function testUploadEntityFormDisplay() {
+    $display = entity_get_form_display('node', 'page', 'default');
+    $component = $display->getComponent('upload');
+    $this->assertIdentical('file_generic', $component['type']);
+
+    $display = entity_get_form_display('node', 'story', 'default');
+    $component = $display->getComponent('upload');
+    $this->assertIdentical('file_generic', $component['type']);
+
+    // Assure this doesn't exist.
+    $display = entity_get_form_display('node', 'article', 'default');
+    $component = $display->getComponent('upload');
+    $this->assertTrue(is_null($component));
+
+    $this->assertIdentical(array('node', 'page', 'default', 'upload'), entity_load('migration', 'd6_upload_entity_form_display')->getIdMap()->lookupDestinationID(array('page')));
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateUploadFieldTest.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateUploadFieldTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+
+/**
+ * Uploads migration.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateUploadFieldTest extends MigrateDrupal6TestBase {
+
+  /**
+   * The modules to be enabled during the test.
+   *
+   * @var array
+   */
+  static $modules = array('file', 'node');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->executeMigration('d6_upload_field');
+  }
+
+  /**
+   * Tests the Drupal 6 upload settings to Drupal 8 field migration.
+   */
+  public function testUpload() {
+    $field_storage = FieldStorageConfig::load('node.upload');
+    $this->assertIdentical('node.upload', $field_storage->id());
+    $this->assertIdentical(array('node', 'upload'), entity_load('migration', 'd6_upload_field')->getIdMap()->lookupDestinationID(array('')));
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateUploadInstanceTest.php

@@ -0,0 +1,78 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateUploadInstanceTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\field\Entity\FieldConfig;
+use Drupal\migrate_drupal\Tests\d6\MigrateDrupal6TestBase;
+
+/**
+ * Upload field instance migration.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateUploadInstanceTest extends MigrateDrupal6TestBase {
+
+  /**
+   * The modules to be enabled during the test.
+   *
+   * @var array
+   */
+  static $modules = array('file', 'node');
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    // Add some node mappings to get past checkRequirements().
+    $id_mappings = array(
+      'd6_upload_field' => array(
+        array(array(1), array('node', 'upload')),
+      ),
+      'd6_node_type' => array(
+        array(array('page'), array('page')),
+        array(array('story'), array('story')),
+      ),
+    );
+    $this->prepareMigrations($id_mappings);
+
+    foreach (array('page', 'story') as $type) {
+      entity_create('node_type', array('type' => $type))->save();
+    }
+    entity_create('field_storage_config', array(
+      'entity_type' => 'node',
+      'field_name' => 'upload',
+      'type' => 'file',
+      'translatable' => '0',
+    ))->save();
+
+    $this->executeMigration('d6_upload_field_instance');
+  }
+
+  /**
+   * Tests the Drupal 6 upload settings to Drupal 8 field instance migration.
+   */
+  public function testUploadFieldInstance() {
+    $field = FieldConfig::load('node.page.upload');
+    $settings = $field->getSettings();
+    $this->assertIdentical('node.page.upload', $field->id());
+    $this->assertIdentical('jpg jpeg gif png txt doc xls pdf ppt pps odt ods odp', $settings['file_extensions']);
+    $this->assertIdentical('1MB', $settings['max_filesize']);
+    $this->assertIdentical(TRUE, $settings['description_field']);
+
+    $field = FieldConfig::load('node.story.upload');
+    $this->assertIdentical('node.story.upload', $field->id());
+
+    // Shouldn't exist.
+    $field = FieldConfig::load('node.article.upload');
+    $this->assertTrue(is_null($field));
+
+    $this->assertIdentical(array('node', 'page', 'upload'), entity_load('migration', 'd6_upload_field_instance')->getIdMap()->lookupDestinationID(array('page')));
+  }
+
+}

core/modules/file/src/Tests/Migrate/d6/MigrateUploadTest.php

@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d6\MigrateUploadTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d6;
+
+use Drupal\node\Entity\Node;
+
+/**
+ * Migrate association data between nodes and files.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateUploadTest extends MigrateUploadBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $id_mappings = array(
+      'd6_node:*' => array(
+        array(
+          array(0),
+          array(0),
+        ),
+      ),
+    );
+    $this->prepareMigrations($id_mappings);
+    $this->executeMigration('d6_upload');
+  }
+
+  /**
+   * Test upload migration from Drupal 6 to Drupal 8.
+   */
+  function testUpload() {
+    $node_storage = $this->container->get('entity.manager')->getStorage('node');
+    $node_storage->resetCache(array(1, 2));
+    $nodes = Node::loadMultiple(array(1, 2));
+    $node = $nodes[1];
+    $this->assertIdentical(1, count($node->upload));
+    $this->assertIdentical('1', $node->upload[0]->target_id);
+    $this->assertIdentical('file 1-1-1', $node->upload[0]->description);
+    $this->assertIdentical(FALSE, $node->upload[0]->isDisplayed());
+
+    $node = $nodes[2];
+    $this->assertIdentical(2, count($node->upload));
+    $this->assertIdentical('3', $node->upload[0]->target_id);
+    $this->assertIdentical('file 2-3-3', $node->upload[0]->description);
+    $this->assertIdentical(FALSE, $node->upload[0]->isDisplayed());
+    $this->assertIdentical('2', $node->upload[1]->target_id);
+    $this->assertIdentical(TRUE, $node->upload[1]->isDisplayed());
+    $this->assertIdentical('file 2-3-2', $node->upload[1]->description);
+  }
+
+}

core/modules/file/src/Tests/Migrate/d7/MigrateFileTest.php

@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\file\Tests\Migrate\d7\MigrateFileTest.
+ */
+
+namespace Drupal\file\Tests\Migrate\d7;
+
+use Drupal\file\Entity\File;
+use Drupal\file\FileInterface;
+use Drupal\migrate_drupal\Tests\d7\MigrateDrupal7TestBase;
+
+/**
+ * Migrates all files in the file_managed table.
+ *
+ * @group file
+ */
+class MigrateFileTest extends MigrateDrupal7TestBase {
+
+  static $modules = ['file'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->installEntitySchema('file');
+
+    $fs = \Drupal::service('file_system');
+    // The public file directory active during the test will serve as the
+    // root of the fictional Drupal 7 site we're migrating.
+    $fs->mkdir('public://sites/default/files', NULL, TRUE);
+    file_put_contents('public://sites/default/files/cube.jpeg', str_repeat('*', 3620));
+
+    /** @var \Drupal\migrate\Entity\MigrationInterface $migration */
+    $migration = entity_load('migration', 'd7_file');
+    // Set the destination plugin's source_base_path configuration value, which
+    // would normally be set by the user running the migration.
+    $migration->set('destination', [
+      'plugin' => 'entity:file',
+      // Note that source_base_path must include a trailing slash because it's
+      // prepended directly to the value of the source path property.
+      'source_base_path' => $fs->realpath($this->publicFilesDirectory) . '/',
+      // This is set in the migration's YAML file, but we need to repeat it
+      // here because all the destination configuration must be set at once.
+      'source_path_property' => 'filepath',
+    ]);
+    $this->executeMigration($migration);
+  }
+
+  /**
+   * Tests a single file entity.
+   *
+   * @param integer $id
+   *  The file ID.
+   * @param string $name
+   *  The expected file name.
+   * @param string $uri
+   *  The expected URI.
+   * @param string $mime
+   *  The expected MIME type.
+   * @param integer $size
+   *  The expected file size.
+   * @param integer $created
+   *  The expected creation time.
+   * @param integer $changed
+   *  The expected modification time.
+   * @param integer $uid
+   *  The expected owner ID.
+   */
+  protected function assertEntity($id, $name, $uri, $mime, $size, $created, $changed, $uid) {
+    /** @var \Drupal\file\FileInterface $file */
+    $file = File::load($id);
+    $this->assertTrue($file instanceof FileInterface);
+    $this->assertIdentical($name, $file->getFilename());
+    $this->assertIdentical($uri, $file->getFileUri());
+    $this->assertTrue(file_exists($uri));
+    $this->assertIdentical($mime, $file->getMimeType());
+    $this->assertIdentical($size, $file->getSize());
+    // isPermanent(), isTemporary(), etc. are determined by the status column.
+    $this->assertTrue($file->isPermanent());
+    $this->assertIdentical($created, $file->getCreatedTime());
+    $this->assertIdentical($changed, $file->getChangedTime());
+    $this->assertIdentical($uid, $file->getOwnerId());
+  }
+
+  /**
+   * Tests that all expected files are migrated.
+   */
+  public function testFileMigration() {
+    $this->assertEntity(1, 'cube.jpeg', 'public://cube.jpeg', 'image/jpeg', '3620', '1421727515', '1421727515', '1');
+  }
+
+}

core/modules/file/src/Tests/Views/ExtensionViewsFieldTest.php

@@ -10,7 +10,7 @@ namespace Drupal\file\Tests\Views;
 use Drupal\Core\Render\RenderContext;
 use Drupal\file\Entity\File;
 use Drupal\views\Views;
-use Drupal\views\Tests\ViewUnitTestBase;
+use Drupal\views\Tests\ViewKernelTestBase;
 use Drupal\views\Tests\ViewTestData;
 
 /**
@@ -18,7 +18,7 @@ use Drupal\views\Tests\ViewTestData;
  *
  * @group file
  */
-class ExtensionViewsFieldTest extends ViewUnitTestBase {
+class ExtensionViewsFieldTest extends ViewKernelTestBase {
 
   /**
    * {@inheritdoc}

core/modules/file/src/Tests/Views/FileViewsDataTest.php

@@ -9,7 +9,7 @@ namespace Drupal\file\Tests\Views;
 
 use Drupal\field\Entity\FieldStorageConfig;
 use Drupal\field\Entity\FieldConfig;
-use Drupal\views\Tests\ViewUnitTestBase;
+use Drupal\views\Tests\ViewKernelTestBase;
 use Drupal\views\Views;
 
 /**
@@ -17,7 +17,7 @@ use Drupal\views\Views;
  *
  * @group file
  */
-class FileViewsDataTest extends ViewUnitTestBase {
+class FileViewsDataTest extends ViewKernelTestBase {
 
   /**
    * Modules to install.