updated core from 8.4 to 8.5 : bug with login_destination

core/modules/media/tests/modules/media_test_source/config/schema/media_test_source.schema.yml

@@ -13,3 +13,11 @@ media.source.test_translation:
 media.source.test_constraints:
   type: media.source.test
   label: 'Test media source with constraints configuration'
+
+media.source.test_hidden_source_field:
+  type: media.source.test
+  label: 'Test media source with hidden source field'
+
+media.source.test_different_displays:
+  type: media.source.test
+  label: 'Test media source with different source field displays'

core/modules/media/tests/modules/media_test_source/media_test_source.info.yml

@@ -5,8 +5,8 @@ description: 'Provides test media source to test configuration forms.'
 package: Testing
 # version: VERSION
 
-# Information added by Drupal.org packaging script on 2018-01-03
-version: '8.4.4'
+# Information added by Drupal.org packaging script on 2018-03-07
+version: '8.5.0'
 core: '8.x'
 project: 'drupal'
-datestamp: 1515021228
+datestamp: 1520457825

core/modules/media/tests/modules/media_test_source/src/Plugin/media/Source/TestDifferentDisplays.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Drupal\media_test_source\Plugin\media\Source;
+
+use Drupal\Core\Entity\Display\EntityFormDisplayInterface;
+use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
+use Drupal\media\MediaTypeInterface;
+
+/**
+ * Provides test media source.
+ *
+ * @MediaSource(
+ *   id = "test_different_displays",
+ *   label = @Translation("Test source with different displays"),
+ *   description = @Translation("Test source with different displays."),
+ *   allowed_field_types = {"entity_reference"},
+ * )
+ */
+class TestDifferentDisplays extends Test {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareViewDisplay(MediaTypeInterface $type, EntityViewDisplayInterface $display) {
+    parent::prepareViewDisplay($type, $display);
+    $source_name = $this->getSourceFieldDefinition($type)->getName();
+    $source_component = $display->getComponent($source_name) ?: [];
+    $source_component['type'] = 'entity_reference_entity_id';
+    $display->setComponent($source_name, $source_component);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareFormDisplay(MediaTypeInterface $type, EntityFormDisplayInterface $display) {
+    parent::prepareFormDisplay($type, $display);
+    $source_name = $this->getSourceFieldDefinition($type)->getName();
+    $source_component = $display->getComponent($source_name) ?: [];
+    $source_component['type'] = 'entity_reference_autocomplete_tags';
+    $display->setComponent($source_name, $source_component);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getSourceFieldName() {
+    return 'field_media_different_display';
+  }
+
+}

core/modules/media/tests/modules/media_test_source/src/Plugin/media/Source/TestWithHiddenSourceField.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace Drupal\media_test_source\Plugin\media\Source;
+
+use Drupal\Core\Entity\Display\EntityFormDisplayInterface;
+use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
+use Drupal\media\MediaTypeInterface;
+
+/**
+ * Provides test media source.
+ *
+ * @MediaSource(
+ *   id = "test_hidden_source_field",
+ *   label = @Translation("Test source with hidden source field"),
+ *   description = @Translation("Test media source with hidden source field."),
+ *   allowed_field_types = {"string"},
+ * )
+ */
+class TestWithHiddenSourceField extends Test {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareViewDisplay(MediaTypeInterface $type, EntityViewDisplayInterface $display) {
+    $display->removeComponent($this->getSourceFieldDefinition($type)->getName());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareFormDisplay(MediaTypeInterface $type, EntityFormDisplayInterface $display) {
+    $display->removeComponent($this->getSourceFieldDefinition($type)->getName());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getSourceFieldName() {
+    return 'field_media_hidden';
+  }
+
+}

core/modules/media/tests/modules/media_test_type/media_test_type.info.yml

@@ -5,10 +5,11 @@ description: 'Provides test type for a media item.'
 package: Testing
 # version: VERSION
 dependencies:
+  - media
   - media_test_source
 
-# Information added by Drupal.org packaging script on 2018-01-03
-version: '8.4.4'
+# Information added by Drupal.org packaging script on 2018-03-07
+version: '8.5.0'
 core: '8.x'
 project: 'drupal'
-datestamp: 1515021228
+datestamp: 1520457825

core/modules/media/tests/modules/media_test_views/media_test_views.info.yml

@@ -8,8 +8,8 @@ dependencies:
   - media
   - views
 
-# Information added by Drupal.org packaging script on 2018-01-03
-version: '8.4.4'
+# Information added by Drupal.org packaging script on 2018-03-07
+version: '8.5.0'
 core: '8.x'
 project: 'drupal'
-datestamp: 1515021228
+datestamp: 1520457825

core/modules/media/tests/src/Functional/MediaAccessTest.php

@@ -12,10 +12,27 @@ use Drupal\user\RoleInterface;
  *
  * @group media
  */
-class MediaAccessTest extends MediaUiFunctionalTest {
+class MediaAccessTest extends MediaFunctionalTestBase {
 
   use AssertPageCacheContextsAndTagsTrait;
 
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'block',
+    'media_test_source',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    // This is needed to provide the user cache context for a below assertion.
+    $this->drupalPlaceBlock('local_tasks_block');
+  }
+
   /**
    * Test some access control functionality.
    */
@@ -64,43 +81,66 @@ class MediaAccessTest extends MediaUiFunctionalTest {
     $this->assertSame("The 'view media' permission is required and the media item must be published.", $access_result->getReason());
     $this->grantPermissions($role, ['view media']);
     $this->drupalGet('media/' . $media->id());
-    $this->assertCacheContext('user');
+    $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(200);
 
+    // Test 'create BUNDLE media' permission.
+    $this->drupalGet('media/add/' . $media_type->id());
+    $this->assertCacheContext('user.permissions');
+    $assert_session->statusCodeEquals(403);
+    $permissions = ['create ' . $media_type->id() . ' media'];
+    $this->grantPermissions($role, $permissions);
+    $this->drupalGet('media/add/' . $media_type->id());
+    $this->assertCacheContext('user.permissions');
+    $assert_session->statusCodeEquals(200);
+    user_role_revoke_permissions($role->id(), $permissions);
+    $role = Role::load(RoleInterface::AUTHENTICATED_ID);
+
     // Test 'create media' permission.
     $this->drupalGet('media/add/' . $media_type->id());
     $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(403);
-    $this->grantPermissions($role, ['create media']);
+    $permissions = ['create media'];
+    $this->grantPermissions($role, $permissions);
     $this->drupalGet('media/add/' . $media_type->id());
     $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(200);
+    user_role_revoke_permissions($role->id(), $permissions);
+    $role = Role::load(RoleInterface::AUTHENTICATED_ID);
 
-    // Test 'update media' and 'delete media' permissions.
+    // Test 'edit own BUNDLE media' and 'delete own BUNDLE media' permissions.
     $this->drupalGet('media/' . $user_media->id() . '/edit');
-    $this->assertCacheContext('user');
+    $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(403);
     $this->drupalGet('media/' . $user_media->id() . '/delete');
-    $this->assertCacheContext('user');
+    $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(403);
-    $this->grantPermissions($role, ['update media']);
-    $this->grantPermissions($role, ['delete media']);
+    $permissions = [
+      'edit own ' . $user_media->bundle() . ' media',
+      'delete own ' . $user_media->bundle() . ' media',
+    ];
+    $this->grantPermissions($role, $permissions);
     $this->drupalGet('media/' . $user_media->id() . '/edit');
     $this->assertCacheContext('user');
     $assert_session->statusCodeEquals(200);
     $this->drupalGet('media/' . $user_media->id() . '/delete');
     $this->assertCacheContext('user');
     $assert_session->statusCodeEquals(200);
+    user_role_revoke_permissions($role->id(), $permissions);
+    $role = Role::load(RoleInterface::AUTHENTICATED_ID);
 
-    // Test 'update any media' and 'delete any media' permissions.
+    // Test 'edit any BUNDLE media' and 'delete any BUNDLE media' permissions.
     $this->drupalGet('media/' . $media->id() . '/edit');
-    $this->assertCacheContext('user');
+    $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(403);
     $this->drupalGet('media/' . $media->id() . '/delete');
-    $this->assertCacheContext('user');
+    $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(403);
-    $this->grantPermissions($role, ['update any media']);
-    $this->grantPermissions($role, ['delete any media']);
+    $permissions = [
+      'edit any ' . $media->bundle() . ' media',
+      'delete any ' . $media->bundle() . ' media',
+    ];
+    $this->grantPermissions($role, $permissions);
     $this->drupalGet('media/' . $media->id() . '/edit');
     $this->assertCacheContext('user.permissions');
     $assert_session->statusCodeEquals(200);

core/modules/media/tests/src/Functional/MediaCacheTagsTest.php

@@ -7,7 +7,7 @@ use Drupal\media\Entity\Media;
 use Drupal\system\Tests\Entity\EntityWithUriCacheTagsTestBase;
 
 /**
- * Tests the media entity's cache tags.
+ * Tests the media items cache tags.
  *
  * @group media
  */

core/modules/media/tests/src/Functional/MediaContextualLinksTest.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Drupal\Tests\media\Functional;
+
+use Drupal\media\Entity\Media;
+
+/**
+ * Tests views contextual links on media items.
+ *
+ * @group media
+ */
+class MediaContextualLinksTest extends MediaFunctionalTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'contextual',
+  ];
+
+  /**
+   * Tests contextual links.
+   */
+  public function testMediaContextualLinks() {
+    // Create a media type.
+    $mediaType = $this->createMediaType();
+
+    // Create a media item.
+    $media = Media::create([
+      'bundle' => $mediaType->id(),
+      'name' => 'Unnamed',
+    ]);
+    $media->save();
+
+    $user = $this->drupalCreateUser([
+      'administer media',
+      'access contextual links',
+    ]);
+    $this->drupalLogin($user);
+
+    $this->drupalGet('media/' . $media->id());
+    $this->assertSession()->elementAttributeContains('css', 'div[data-contextual-id]', 'data-contextual-id', 'media:media=' . $media->id() . ':');
+  }
+
+}

core/modules/media/tests/src/Functional/MediaFunctionalTestCreateMediaTypeTrait.php

@@ -45,6 +45,7 @@ trait MediaFunctionalTestCreateMediaTypeTrait {
     $this->assertIdentical(SAVED_NEW, $status, 'Media type was created successfully.');
 
     // Ensure that the source field exists.
+    /** @var \Drupal\media\MediaSourceInterface $source */
     $source = $media_type->getSource();
     $source_field = $source->getSourceFieldDefinition($media_type);
     if (!$source_field) {
@@ -61,6 +62,11 @@ trait MediaFunctionalTestCreateMediaTypeTrait {
         ->save();
     }
 
+    // Move source field in form display.
+    entity_get_form_display('media', $id, 'default')
+      ->setComponent($source_field->getName())
+      ->save();
+
     return $media_type;
   }
 

core/modules/media/tests/src/Functional/MediaFunctionalTestTrait.php

@@ -13,18 +13,14 @@ trait MediaFunctionalTestTrait {
    * @var array
    */
   protected static $adminUserPermissions = [
-    // Media entity permissions.
+    // Media module permissions.
+    'access media overview',
     'administer media',
     'administer media fields',
     'administer media form display',
     'administer media display',
     'administer media types',
     'view media',
-    'create media',
-    'update media',
-    'update any media',
-    'delete media',
-    'delete any media',
     // Other permissions.
     'administer views',
     'access content overview',
@@ -32,6 +28,7 @@ trait MediaFunctionalTestTrait {
     'administer content types',
     'administer node fields',
     'administer node form display',
+    'administer node display',
     'bypass node access',
   ];
 

core/modules/media/tests/src/Functional/MediaOverviewPageTest.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Drupal\Tests\media\Functional;
+
+use Drupal\media\Entity\Media;
+use Drupal\user\Entity\Role;
+use Drupal\user\RoleInterface;
+
+/**
+ * Tests the Media overview page.
+ *
+ * @group media
+ */
+class MediaOverviewPageTest extends MediaFunctionalTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->drupalLogin($this->nonAdminUser);
+  }
+
+  /**
+   * Test that the Media overview page (/admin/content/media).
+   */
+  public function testMediaOverviewPage() {
+    $assert_session = $this->assertSession();
+
+    // Check the view exists, is access-restricted, and some defaults are there.
+    $this->drupalGet('/admin/content/media');
+    $assert_session->statusCodeEquals(403);
+    $role = Role::load(RoleInterface::AUTHENTICATED_ID);
+    $this->grantPermissions($role, ['access media overview']);
+    $this->drupalGet('/admin/content/media');
+    $assert_session->statusCodeEquals(200);
+    $assert_session->titleEquals('Media | Drupal');
+    $assert_session->fieldExists('Media name');
+    $assert_session->selectExists('type');
+    $assert_session->selectExists('status');
+    $assert_session->selectExists('langcode');
+    $assert_session->buttonExists('Filter');
+    $header = $assert_session->elementExists('css', 'th#view-thumbnail-target-id-table-column');
+    $this->assertEquals('Thumbnail', $header->getText());
+    $header = $assert_session->elementExists('css', 'th#view-name-table-column');
+    $this->assertEquals('Media name', $header->getText());
+    $header = $assert_session->elementExists('css', 'th#view-bundle-table-column');
+    $this->assertEquals('Type', $header->getText());
+    $header = $assert_session->elementExists('css', 'th#view-uid-table-column');
+    $this->assertEquals('Author', $header->getText());
+    $header = $assert_session->elementExists('css', 'th#view-status-table-column');
+    $this->assertEquals('Status', $header->getText());
+    $header = $assert_session->elementExists('css', 'th#view-changed-table-column');
+    $this->assertEquals('Updated Sort ascending', $header->getText());
+    $header = $assert_session->elementExists('css', 'th#view-operations-table-column');
+    $this->assertEquals('Operations', $header->getText());
+    $assert_session->pageTextContains('No content available.');
+
+    // Create some content for the view.
+    $media_type1 = $this->createMediaType();
+    $media_type2 = $this->createMediaType();
+    $media1 = Media::create([
+      'bundle' => $media_type1->id(),
+      'name' => 'Media 1',
+      'uid' => $this->adminUser->id(),
+    ]);
+    $media1->save();
+    $media2 = Media::create([
+      'bundle' => $media_type2->id(),
+      'name' => 'Media 2',
+      'uid' => $this->adminUser->id(),
+      'status' => FALSE,
+    ]);
+    $media2->save();
+    $media3 = Media::create([
+      'bundle' => $media_type1->id(),
+      'name' => 'Media 3',
+      'uid' => $this->nonAdminUser->id(),
+    ]);
+    $media3->save();
+
+    // Verify the view is now correctly populated.
+    $this->grantPermissions($role, [
+      'view media',
+      'update any media',
+      'delete any media',
+    ]);
+    $this->drupalGet('/admin/content/media');
+    $row1 = $assert_session->elementExists('css', 'table tbody tr:nth-child(1)');
+    $row2 = $assert_session->elementExists('css', 'table tbody tr:nth-child(2)');
+    $row3 = $assert_session->elementExists('css', 'table tbody tr:nth-child(3)');
+
+    // Media thumbnails.
+    $assert_session->elementExists('css', 'td.views-field-thumbnail__target-id img', $row1);
+    $assert_session->elementExists('css', 'td.views-field-thumbnail__target-id img', $row2);
+    $assert_session->elementExists('css', 'td.views-field-thumbnail__target-id img', $row3);
+
+    // Media names.
+    $name1 = $assert_session->elementExists('css', 'td.views-field-name a', $row1);
+    $this->assertEquals($media1->label(), $name1->getText());
+    $name2 = $assert_session->elementExists('css', 'td.views-field-name a', $row2);
+    $this->assertEquals($media2->label(), $name2->getText());
+    $name3 = $assert_session->elementExists('css', 'td.views-field-name a', $row3);
+    $this->assertEquals($media3->label(), $name3->getText());
+    $assert_session->linkByHrefExists('/media/' . $media1->id());
+    $assert_session->linkByHrefExists('/media/' . $media2->id());
+    $assert_session->linkByHrefExists('/media/' . $media3->id());
+
+    // Media types.
+    $type_element1 = $assert_session->elementExists('css', 'td.views-field-bundle', $row1);
+    $this->assertEquals($media_type1->label(), $type_element1->getText());
+    $type_element2 = $assert_session->elementExists('css', 'td.views-field-bundle', $row2);
+    $this->assertEquals($media_type2->label(), $type_element2->getText());
+    $type_element3 = $assert_session->elementExists('css', 'td.views-field-bundle', $row3);
+    $this->assertEquals($media_type1->label(), $type_element3->getText());
+
+    // Media authors.
+    $author_element1 = $assert_session->elementExists('css', 'td.views-field-uid', $row1);
+    $this->assertEquals($this->adminUser->getDisplayName(), $author_element1->getText());
+    $author_element2 = $assert_session->elementExists('css', 'td.views-field-uid', $row2);
+    $this->assertEquals($this->adminUser->getDisplayName(), $author_element2->getText());
+    $author_element3 = $assert_session->elementExists('css', 'td.views-field-uid', $row3);
+    $this->assertEquals($this->nonAdminUser->getDisplayName(), $author_element3->getText());
+
+    // Media publishing status.
+    $status_element1 = $assert_session->elementExists('css', 'td.views-field-status', $row1);
+    $this->assertEquals('Published', $status_element1->getText());
+    $status_element2 = $assert_session->elementExists('css', 'td.views-field-status', $row2);
+    $this->assertEquals('Unpublished', $status_element2->getText());
+    $status_element3 = $assert_session->elementExists('css', 'td.views-field-status', $row3);
+    $this->assertEquals('Published', $status_element3->getText());
+
+    // Timestamp.
+    $expected = \Drupal::service('date.formatter')->format($media1->getChangedTime(), 'short');
+    $changed_element1 = $assert_session->elementExists('css', 'td.views-field-changed', $row1);
+    $this->assertEquals($expected, $changed_element1->getText());
+
+    // Operations.
+    $edit_link1 = $assert_session->elementExists('css', 'td.views-field-operations li.edit a', $row1);
+    $this->assertEquals('Edit', $edit_link1->getText());
+    $assert_session->linkByHrefExists('/media/' . $media1->id() . '/edit');
+    $delete_link1 = $assert_session->elementExists('css', 'td.views-field-operations li.delete a', $row1);
+    $this->assertEquals('Delete', $delete_link1->getText());
+    $assert_session->linkByHrefExists('/media/' . $media1->id() . '/delete');
+  }
+
+}

core/modules/media/tests/src/Functional/MediaRevisionTest.php

@@ -80,6 +80,8 @@ class MediaRevisionTest extends MediaFunctionalTestBase {
     $uri = 'temporary://foo.txt';
     file_put_contents($uri, $this->randomString(128));
 
+    $this->createMediaType(['bundle' => 'file', 'new_revision' => TRUE], 'file');
+
     // Create a media item.
     $this->drupalGet('/media/add/file');
     $page = $this->getSession()->getPage();
@@ -117,6 +119,8 @@ class MediaRevisionTest extends MediaFunctionalTestBase {
   public function testImageMediaRevision() {
     $assert = $this->assertSession();
 
+    $this->createMediaType(['bundle' => 'image', 'new_revision' => TRUE], 'image');
+
     /** @var \Drupal\field\FieldConfigInterface $field */
     // Disable the alt text field, because this is not a JavaScript test and
     // the alt text field will therefore not appear without a full page refresh.

core/modules/media/tests/src/Functional/MediaSourceFileTest.php

@@ -3,7 +3,6 @@
 namespace Drupal\Tests\media\Functional;
 
 use Drupal\field\Entity\FieldConfig;
-use Drupal\media\Entity\MediaType;
 
 /**
  * Tests the file media source.
@@ -12,17 +11,6 @@ use Drupal\media\Entity\MediaType;
  */
 class MediaSourceFileTest extends MediaFunctionalTestBase {
 
-  /**
-   * {@inheritdoc}
-   */
-  protected function setUp() {
-    parent::setUp();
-
-    // We need to test without any default configuration in place.
-    // @TODO: Remove this as part of https://www.drupal.org/node/2883813.
-    MediaType::load('file')->delete();
-  }
-
   /**
    * Test that it's possible to change the allowed file extensions.
    */

core/modules/media/tests/src/Functional/MediaUiFunctionalTest.php

@@ -2,8 +2,12 @@
 
 namespace Drupal\Tests\media\Functional;
 
+use Behat\Mink\Element\NodeElement;
 use Drupal\media\Entity\Media;
-use Drupal\media\Entity\MediaType;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\Url;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
 
 /**
  * Ensures that media UI works correctly.
@@ -29,11 +33,6 @@ class MediaUiFunctionalTest extends MediaFunctionalTestBase {
     parent::setUp();
     $this->drupalPlaceBlock('local_actions_block');
     $this->drupalPlaceBlock('local_tasks_block');
-
-    // We need to test without any default configuration in place.
-    // @TODO: Remove this when https://www.drupal.org/node/2883813 lands.
-    MediaType::load('file')->delete();
-    MediaType::load('image')->delete();
   }
 
   /**
@@ -59,6 +58,8 @@ class MediaUiFunctionalTest extends MediaFunctionalTestBase {
     $page->fillField('name[0][value]', $media_name);
     $revision_log_message = $this->randomString();
     $page->fillField('revision_log_message[0][value]', $revision_log_message);
+    $source_field = $this->randomString();
+    $page->fillField('field_media_test[0][value]', $source_field);
     $page->pressButton('Save');
     $media_id = $this->container->get('entity.query')->get('media')->execute();
     $media_id = reset($media_id);
@@ -179,4 +180,352 @@ class MediaUiFunctionalTest extends MediaFunctionalTestBase {
     $assert_session->pageTextContains($second_media_item->getName());
   }
 
+  /**
+   * Test that media in ER fields use the Rendered Entity formatter by default.
+   */
+  public function testRenderedEntityReferencedMedia() {
+    $page = $this->getSession()->getPage();
+    $assert_session = $this->assertSession();
+
+    $this->drupalCreateContentType(['type' => 'page', 'name' => 'Page']);
+    $this->drupalGet('/admin/structure/types/manage/page/fields/add-field');
+    $page->selectFieldOption('new_storage_type', 'field_ui:entity_reference:media');
+    $page->fillField('label', 'Foo field');
+    $page->fillField('field_name', 'foo_field');
+    $page->pressButton('Save and continue');
+    $this->drupalGet('/admin/structure/types/manage/page/display');
+    $assert_session->fieldValueEquals('fields[field_foo_field][type]', 'entity_reference_entity_view');
+  }
+
+  /**
+   * Data provider for testMediaReferenceWidget().
+   *
+   * @return array[]
+   *   Test data. See testMediaReferenceWidget() for the child array structure.
+   */
+  public function providerTestMediaReferenceWidget() {
+    return [
+      // Single-value fields with a single media type and the default widget:
+      // - The user can create and list the media.
+      'single_value:single_type:create_list' => [1, [TRUE], TRUE],
+      // - The user can list but not create the media.
+      'single_value:single_type:list' => [1, [FALSE], TRUE],
+      // - The user can create but not list the media.
+      'single_value:single_type:create' => [1, [TRUE], FALSE],
+      // - The user can neither create nor list the media.
+      'single_value:single_type' => [1, [FALSE], FALSE],
+
+      // Single-value fields with the tags-style widget:
+      // - The user can create and list the media.
+      'single_value:single_type:create_list:tags' => [1, [TRUE], TRUE, 'entity_reference_autocomplete_tags'],
+      // - The user can list but not create the media.
+      'single_value:single_type:list:tags' => [1, [FALSE], TRUE, 'entity_reference_autocomplete_tags'],
+      // - The user can create but not list the media.
+      'single_value:single_type:create:tags' => [1, [TRUE], FALSE, 'entity_reference_autocomplete_tags'],
+      // - The user can neither create nor list the media.
+      'single_value:single_type:tags' => [1, [FALSE], FALSE, 'entity_reference_autocomplete_tags'],
+
+      // Single-value fields with two media types:
+      // - The user can create both types.
+      'single_value:two_type:create2_list' => [1, [TRUE, TRUE], TRUE],
+      // - The user can create only one type.
+      'single_value:two_type:create1_list' => [1, [TRUE, FALSE], TRUE],
+      // - The user cannot create either type.
+      'single_value:two_type:list' => [1, [FALSE, FALSE], TRUE],
+
+      // Multiple-value field with a cardinality of 3, with media the user can
+      // create and list.
+      'multi_value:single_type:create_list' => [3, [TRUE], TRUE],
+      // The same, with the tags field.
+      'multi-value:single_type:create_list:tags' => [3, [TRUE], TRUE, 'entity_reference_autocomplete_tags'],
+
+      // Unlimited value field.
+      'unlimited_value:single_type:create_list' => [FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED, [TRUE], TRUE],
+      // Unlimited value field with the tags widget.
+      'unlimited_value:single_type:create_list' => [FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED, [TRUE], TRUE, 'entity_reference_autocomplete_tags'],
+    ];
+  }
+
+  /**
+   * Tests the default autocomplete widgets for media reference fields.
+   *
+   * @param int $cardinality
+   *   The field cardinality.
+   * @param bool[] $media_type_create_access
+   *   An array of booleans indicating whether to grant the test user create
+   *   access for each media type. A media type is created automatically for
+   *   each; for example, an array [TRUE, FALSE] would create two media types,
+   *   one that allows the user to create media and a second that does not.
+   * @param bool $list_access
+   *   Whether to grant the test user access to list media.
+   *
+   * @see media_field_widget_entity_reference_autocomplete_form_alter()
+   * @see media_field_widget_multiple_entity_reference_autocomplete_form_alter()
+   *
+   * @dataProvider providerTestMediaReferenceWidget
+   */
+  public function testMediaReferenceWidget($cardinality, array $media_type_create_access, $list_access, $widget_id = 'entity_reference_autocomplete') {
+    $assert_session = $this->assertSession();
+
+    // Create two content types.
+    $non_media_content_type = $this->createContentType();
+    $content_type = $this->createContentType();
+
+    // Create some media types.
+    $media_types = [];
+    $permissions = [];
+    $create_media_types = [];
+    foreach ($media_type_create_access as $id => $access) {
+      if ($access) {
+        $create_media_types[] = "media_type_$id";
+        $permissions[] = "create media_type_$id media";
+      }
+      $this->createMediaType(['bundle' => "media_type_$id"]);
+      $media_types["media_type_$id"] = "media_type_$id";
+    }
+
+    // Create a user that can create content of the type, with other
+    // permissions as given by the data provider.
+    $permissions[] = "create {$content_type->id()} content";
+    if ($list_access) {
+      $permissions[] = "access media overview";
+    }
+    $test_user = $this->drupalCreateUser($permissions);
+
+    // Create a non-media entity reference.
+    $non_media_storage = FieldStorageConfig::create([
+      'field_name' => 'field_not_a_media_field',
+      'entity_type' => 'node',
+      'type' => 'entity_reference',
+      'cardinality' => FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED,
+      'settings' => [
+        'target_type' => 'node',
+      ],
+    ]);
+    $non_media_storage->save();
+    $non_media_field = FieldConfig::create([
+      'label' => 'No media here!',
+      'field_storage' => $non_media_storage,
+      'entity_type' => 'node',
+      'bundle' => $non_media_content_type->id(),
+      'settings' => [
+        'handler' => 'default',
+        'handler_settings' => [
+          'target_bundles' => [
+            $non_media_content_type->id() => $non_media_content_type->id(),
+          ],
+        ],
+      ],
+    ]);
+    $non_media_field->save();
+    \Drupal::entityTypeManager()
+      ->getStorage('entity_form_display')
+      ->load('node.' . $non_media_content_type->id() . '.default')
+      ->setComponent('field_not_a_media_field', [
+        'type' => $widget_id,
+      ])
+      ->save();
+
+    // Create a media field through the user interface to ensure that the
+    // help text handling does not break the default value entry on the field
+    // settings form.
+    // Using drupalPostForm() to avoid dealing with JavaScript on the previous
+    // page in the field creation.
+    $edit = [
+      'new_storage_type' => 'field_ui:entity_reference:media',
+      'label' => "Media (cardinality $cardinality)",
+      'field_name' => 'media_reference',
+    ];
+    $this->drupalPostForm("admin/structure/types/manage/{$content_type->id()}/fields/add-field", $edit, 'Save and continue');
+    $edit = [];
+    foreach ($media_types as $type) {
+      $edit["settings[handler_settings][target_bundles][$type]"] = TRUE;
+    }
+    $this->drupalPostForm("admin/structure/types/manage/{$content_type->id()}/fields/node.{$content_type->id()}.field_media_reference", $edit, "Save settings");
+    \Drupal::entityTypeManager()
+      ->getStorage('entity_form_display')
+      ->load('node.' . $content_type->id() . '.default')
+      ->setComponent('field_media_reference', [
+        'type' => $widget_id,
+      ])
+      ->save();
+
+    // Some of the expected texts.
+    $create_help = 'Create your media on the media add page (opens a new window), then add it by name to the field below.';
+    $list_text = 'See the media list (opens a new window) to help locate media.';
+    $use_help = 'Type part of the media name.';
+    $create_header = "Create new media";
+    $use_header = "Use existing media";
+
+    // First check that none of the help texts are on the non-media content.
+    $this->drupalGet("/node/add/{$non_media_content_type->id()}");
+    $this->assertNoHelpTexts([
+      $create_header,
+      $create_help,
+      $use_header,
+      $use_help,
+      $list_text,
+      'Allowed media types:',
+    ]);
+
+    // Now, check that the widget displays the expected help text under the
+    // given conditions for the test user.
+    $this->drupalLogin($test_user);
+    $this->drupalGet("/node/add/{$content_type->id()}");
+
+    // Specific expected help texts for the media field.
+    $create_header = "Create new media";
+    $use_header = "Use existing media";
+    $type_list = 'Allowed media types: ' . implode(", ", array_keys($media_types));
+
+    $fieldset_selector = '#edit-field-media-reference-wrapper fieldset';
+    $fieldset = $assert_session->elementExists('css', $fieldset_selector);
+
+    $this->assertSame("Media (cardinality $cardinality)", $assert_session->elementExists('css', 'legend', $fieldset)->getText());
+
+    // Assert text that should be displayed regardless of other access.
+    $this->assertHelpTexts([$use_header, $use_help, $type_list], $fieldset_selector);
+
+    // The entire section for creating new media should only be displayed if
+    // the user can create at least one media of the type.
+    if ($create_media_types) {
+      if (count($create_media_types) === 1) {
+        $url = Url::fromRoute('entity.media.add_form')->setRouteParameter('media_type', $create_media_types[0]);
+      }
+      else {
+        $url = Url::fromRoute('entity.media.add_page');
+      }
+      $this->assertHelpTexts([$create_header, $create_help], $fieldset_selector);
+      $this->assertHelpLink(
+        $fieldset,
+        'media add page',
+        [
+          'target' => '_blank',
+          'href' => $url->toString(),
+        ]
+      );
+    }
+    else {
+      $this->assertNoHelpTexts([$create_header, $create_help]);
+      $this->assertNoHelpLink($fieldset, 'media add page');
+    }
+
+    if ($list_access) {
+      $this->assertHelpTexts([$list_text], $fieldset_selector);
+      $this->assertHelpLink(
+        $fieldset,
+        'media list',
+        [
+          'target' => '_blank',
+          'href' => Url::fromRoute('entity.media.collection')->toString(),
+        ]
+      );
+    }
+    else {
+      $this->assertNoHelpTexts([$list_text]);
+      $this->assertNoHelpLink($fieldset, 'media list');
+    }
+  }
+
+  /**
+   * Asserts that the given texts are present exactly once.
+   *
+   * @param string[] $texts
+   *   A list of the help texts to check.
+   * @param string $selector
+   *   (optional) The selector to search.
+   */
+  public function assertHelpTexts(array $texts, $selector = '') {
+    $assert_session = $this->assertSession();
+    foreach ($texts as $text) {
+      // We only want to escape single quotes, so use str_replace() rather than
+      // addslashes().
+      $text = str_replace("'", "\'", $text);
+      if ($selector) {
+        $assert_session->elementsCount('css', $selector . ":contains('$text')", 1);
+      }
+      else {
+        $assert_session->pageTextContains($text);
+      }
+    }
+  }
+
+  /**
+   * Asserts that none of the given texts are present.
+   *
+   * @param string[] $texts
+   *   A list of the help texts to check.
+   */
+  public function assertNoHelpTexts(array $texts) {
+    $assert_session = $this->assertSession();
+    foreach ($texts as $text) {
+      $assert_session->pageTextNotContains($text);
+    }
+  }
+
+  /**
+   * Asserts whether a given link is present.
+   *
+   * @param \Behat\Mink\Element\NodeElement $element
+   *   The element to search.
+   * @param string $text
+   *   The link text.
+   * @param string[] $attributes
+   *   An associative array of any expected attributes, keyed by the
+   *   attribute name.
+   */
+  protected function assertHelpLink(NodeElement $element, $text, array $attributes = []) {
+    // Find all the links inside the element.
+    $link = $element->findLink($text);
+
+    $this->assertNotEmpty($link);
+    foreach ($attributes as $attribute => $value) {
+      $this->assertEquals($link->getAttribute($attribute), $value);
+    }
+  }
+
+  /**
+   * Asserts that a given link is not present.
+   *
+   * @param \Behat\Mink\Element\NodeElement $element
+   *   The element to search.
+   * @param string $text
+   *   The link text.
+   */
+  protected function assertNoHelpLink(NodeElement $element, $text) {
+    $assert_session = $this->assertSession();
+    // Assert that the link and its text are not present anywhere on the page.
+    $assert_session->elementNotExists('named', ['link', $text], $element);
+    $assert_session->pageTextNotContains($text);
+  }
+
+  /**
+   * Test the media collection route.
+   */
+  public function testMediaCollectionRoute() {
+    /** @var \Drupal\Core\Entity\EntityStorageInterface $media_storage */
+    $media_storage = $this->container->get('entity_type.manager')->getStorage('media');
+
+    $this->container->get('module_installer')->uninstall(['views']);
+
+    // Create a media type and media item.
+    $media_type = $this->createMediaType();
+    $media = $media_storage->create([
+      'bundle' => $media_type->id(),
+      'name' => 'Unnamed',
+    ]);
+    $media->save();
+
+    $this->drupalGet($media->toUrl('collection'));
+
+    $assert_session = $this->assertSession();
+
+    // Media list table exists.
+    $assert_session->elementExists('css', 'th:contains("Media Name")');
+    $assert_session->elementExists('css', 'th:contains("Type")');
+    $assert_session->elementExists('css', 'th:contains("Operations")');
+    // Media item is present.
+    $assert_session->elementExists('css', 'td:contains("Unnamed")');
+  }
+
 }

core/modules/media/tests/src/Functional/Update/MediaUpdateTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\Tests\media\Functional\Update;
+
+use Drupal\FunctionalTests\Update\UpdatePathTestBase;
+use Drupal\user\Entity\Role;
+
+/**
+ * Tests that media settings are properly updated during database updates.
+ *
+ * @group media
+ */
+class MediaUpdateTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../../system/tests/fixtures/update/drupal-8.bare.standard.php.gz',
+      __DIR__ . '/../../../fixtures/update/drupal-8.media-enabled.php',
+    ];
+  }
+
+  /**
+   * Tests that media permissions are correctly migrated.
+   *
+   * @see media_update_8500()
+   */
+  public function testBundlePermission() {
+    $role = Role::load(Role::AUTHENTICATED_ID);
+
+    $this->grantPermissions($role, [
+      'update media',
+      'update any media',
+      'delete media',
+      'delete any media',
+      'create media',
+    ]);
+
+    $this->runUpdates();
+
+    /** @var \Drupal\user\RoleInterface $role */
+    $role = Role::load(Role::AUTHENTICATED_ID);
+
+    $media_types = \Drupal::entityQuery('media_type')->execute();
+    foreach ($media_types as $media_type) {
+      $this->assertTrue($role->hasPermission("create $media_type media"));
+      $this->assertTrue($role->hasPermission("edit own $media_type media"));
+      $this->assertTrue($role->hasPermission("edit any $media_type media"));
+      $this->assertTrue($role->hasPermission("delete own $media_type media"));
+      $this->assertTrue($role->hasPermission("delete any $media_type media"));
+    }
+  }
+
+}

core/modules/media/tests/src/FunctionalJavascript/MediaDisplayTest.php

@@ -0,0 +1,173 @@
+<?php
+
+namespace Drupal\Tests\media\FunctionalJavascript;
+
+use Drupal\Core\Config\FileStorage;
+use Drupal\Core\Config\InstallStorage;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\media\Entity\Media;
+use Drupal\node\Entity\Node;
+use Drupal\node\Entity\NodeType;
+
+/**
+ * Basic display tests for Media.
+ *
+ * @group media
+ */
+class MediaDisplayTest extends MediaJavascriptTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    // Install the optional configs from the standard profile.
+    $extension_path = drupal_get_path('profile', 'standard');
+    $optional_install_path = $extension_path . '/' . InstallStorage::CONFIG_OPTIONAL_DIRECTORY;
+    $storage = new FileStorage($optional_install_path);
+    $this->container->get('config.installer')->installOptionalConfig($storage, '');
+    // Reset all the static caches and list caches.
+    $this->container->get('config.factory')->reset();
+  }
+
+  /**
+   * Test basic media display.
+   */
+  public function testMediaDisplay() {
+    $assert_session = $this->assertSession();
+    $page = $this->getSession()->getPage();
+
+    $media_type = $this->createMediaType();
+
+    // Create a media item.
+    $media = Media::create([
+      'bundle' => $media_type->id(),
+      'name' => 'Fantastic!',
+    ]);
+    $media->save();
+
+    $this->drupalGet('media/' . $media->id());
+    // Verify the "name" field is really not present.
+    $assert_session->elementNotExists('css', '.field--name-name');
+
+    // Enable the field on the display and verify it becomes visible on the UI.
+    $this->drupalGet("/admin/structure/media/manage/{$media_type->id()}/display");
+    $page->selectFieldOption('fields[name][region]', 'content');
+    $assert_session->waitForElementVisible('css', '#edit-fields-name-settings-edit');
+    $page->pressButton('Save');
+    $this->drupalGet('media/' . $media->id());
+    // Verify the name is present, and its text matches what is expected.
+    $assert_session->elementExists('css', '.field--name-name');
+    $name_field = $page->find('css', '.field--name-name .field__item');
+    $this->assertEquals($media->label(), $name_field->getText());
+
+    // In the standard profile, there are some pre-cooked types. Make sure the
+    // elements configured on their displays are the expected ones.
+    $this->drupalGet('media/add/image');
+    $image_media_name = 'Fantastic image asset!';
+    $page->fillField('name[0][value]', $image_media_name);
+    $page->attachFileToField('files[field_media_image_0]', \Drupal::root() . '/core/modules/media/tests/fixtures/example_1.jpeg');
+    $result = $assert_session->waitForButton('Remove');
+    $this->assertNotEmpty($result);
+    $page->fillField('field_media_image[0][alt]', 'Image Alt Text 1');
+    $page->pressButton('Save');
+    $image_media_id = $this->container->get('entity.query')->get('media')
+      ->sort('mid', 'DESC')
+      ->execute();
+    $image_media_id = reset($image_media_id);
+
+    // Here we expect to see only the image, nothing else.
+    // Assert only one element in the content region.
+    $this->assertEquals(1, count($page->findAll('css', '.media--type-image > div')));
+    // Assert the image is present inside the media element.
+    $media_item = $assert_session->elementExists('css', '.media--type-image > div');
+    $assert_session->elementExists('css', 'img', $media_item);
+    // Assert that the image src is the original image and not an image style.
+    $media_image = $assert_session->elementExists('css', '.media--type-image img');
+    $expected_image_src = file_url_transform_relative(file_create_url(\Drupal::token()->replace('public://[date:custom:Y]-[date:custom:m]/example_1.jpeg')));
+    $this->assertEquals($expected_image_src, $media_image->getAttribute('src'));
+
+    $test_filename = $this->randomMachineName() . '.txt';
+    $test_filepath = 'public://' . $test_filename;
+    file_put_contents($test_filepath, $this->randomMachineName());
+    $this->drupalGet("media/add/file");
+    $page->fillField('name[0][value]', 'File media 1');
+    $page->attachFileToField("files[field_media_file_0]", \Drupal::service('file_system')->realpath($test_filepath));
+    $result = $assert_session->waitForButton('Remove');
+    $this->assertNotEmpty($result);
+    $page->pressButton('Save');
+
+    // Here we expect to see only the linked filename.
+    // Assert only one element in the content region.
+    $this->assertEquals(1, count($page->findAll('css', 'article.media--type-file > div')));
+    // Assert the file link is present, and its text matches the filename.
+    $assert_session->elementExists('css', 'article.media--type-file .field--name-field-media-file a');
+    $link = $page->find('css', 'article.media--type-file .field--name-field-media-file a');
+    $this->assertEquals($test_filename, $link->getText());
+
+    // Create a node type "page" to use as host entity.
+    $node_type = NodeType::create([
+      'type' => 'page',
+      'name' => 'Page',
+    ]);
+    $node_type->save();
+
+    // Reference the created media using an entity_refernce field and make sure
+    // the output is what we expect.
+    $storage = FieldStorageConfig::create([
+      'entity_type' => 'node',
+      'field_name' => 'field_related_media',
+      'type' => 'entity_reference',
+      'settings' => [
+        'target_type' => 'media',
+      ],
+    ]);
+    $storage->save();
+
+    FieldConfig::create([
+      'field_storage' => $storage,
+      'entity_type' => 'node',
+      'bundle' => $node_type->id(),
+      'label' => 'Related media',
+      'settings' => [
+        'handler_settings' => [
+          'target_bundles' => [
+            'image' => 'image',
+          ],
+        ],
+      ],
+    ])->save();
+
+    entity_get_display('node', $node_type->id(), 'default')
+      ->setComponent('field_related_media', [
+        'type' => 'entity_reference_entity_view',
+        'label' => 'hidden',
+        'settings' => [
+          'view_mode' => 'full',
+        ],
+      ])->save();
+
+    $node = Node::create([
+      'title' => 'Host node',
+      'type' => $node_type->id(),
+      'field_related_media' => [
+        'target_id' => $image_media_id,
+      ],
+    ]);
+    $node->save();
+
+    $this->drupalGet('/node/' . $node->id());
+    // Media field is there.
+    $assert_session->elementExists('css', '.field--name-field-related-media');
+    // Media name element is not there.
+    $assert_session->elementNotExists('css', '.field--name-name');
+    $assert_session->pageTextNotContains($image_media_name);
+    // Only one element is present inside the media container.
+    $this->assertEquals(1, count($page->findAll('css', '.field--name-field-related-media article.media--type-image > div')));
+    // Assert the image is present.
+    $assert_session->elementExists('css', '.field--name-field-related-media article.media--type-image img');
+  }
+
+}

core/modules/media/tests/src/FunctionalJavascript/MediaReferenceFieldHelpTest.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Drupal\Tests\media\FunctionalJavascript;
+
+use Drupal\Component\Utility\Html;
+
+/**
+ * Tests related to media reference fields.
+ *
+ * @group media
+ */
+class MediaReferenceFieldHelpTest extends MediaJavascriptTestBase {
+
+  /**
+   * Test our custom help texts when creating a field.
+   *
+   * @see media_form_field_ui_field_storage_add_form_alter()
+   */
+  public function testFieldCreationHelpText() {
+    $assert_session = $this->assertSession();
+    $page = $this->getSession()->getPage();
+
+    $type = $this->drupalCreateContentType([
+      'type' => 'foo',
+    ]);
+    $this->drupalGet("/admin/structure/types/manage/{$type->id()}/fields/add-field");
+
+    $field_types = [
+      'file',
+      'image',
+      'field_ui:entity_reference:media',
+    ];
+    $description_ids = array_map(function ($item) {
+      return '#edit-description-' . Html::cleanCssIdentifier($item);
+    }, $field_types);
+
+    // Choose a boolean field, none of the description containers should be
+    // visible.
+    $assert_session->optionExists('edit-new-storage-type', 'boolean');
+    $page->selectFieldOption('edit-new-storage-type', 'boolean');
+    foreach ($description_ids as $description_id) {
+      $this->assertFalse($assert_session->elementExists('css', $description_id)->isVisible());
+    }
+    // Select each of the file, image, and media fields and verify their
+    // descriptions are now visible and match the expected text.
+    $help_text = 'Use Media reference fields for most files, images, audio, videos, and remote media. Use File or Image reference fields when creating your own media types, or for legacy files and images created before enabling the Media module.';
+    foreach ($field_types as $field_name) {
+      $assert_session->optionExists('edit-new-storage-type', $field_name);
+      $page->selectFieldOption('edit-new-storage-type', $field_name);
+      $field_description_element = $assert_session->elementExists('css', '#edit-description-' . Html::cleanCssIdentifier($field_name));
+      $this->assertTrue($field_description_element->isVisible());
+      $this->assertEquals($help_text, $field_description_element->getText());
+    }
+  }
+
+}

core/modules/media/tests/src/FunctionalJavascript/MediaSourceAudioVideoTest.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Drupal\Tests\media\FunctionalJavascript;
+
+use Drupal\Core\Entity\Entity\EntityViewDisplay;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\file\Entity\File;
+
+/**
+ * Tests the Audio and Video media sources.
+ *
+ * @group media
+ */
+class MediaSourceAudioVideoTest extends MediaSourceTestBase {
+
+  /**
+   * Check the Audio source functionality.
+   */
+  public function testAudioTypeCreation() {
+    $assert_session = $this->assertSession();
+    $page = $this->getSession()->getPage();
+
+    $source_id = 'audio_file';
+    $type_name = 'audio_type';
+    $field_name = 'field_media_' . $source_id;
+    $this->doTestCreateMediaType($type_name, $source_id);
+
+    // Check that the source field was created with the correct settings.
+    $storage = FieldStorageConfig::load("media.$field_name");
+    $this->assertInstanceOf(FieldStorageConfig::class, $storage);
+    $field = FieldConfig::load("media.$type_name.$field_name");
+    $this->assertInstanceOf(FieldConfig::class, $field);
+    $this->assertSame('mp3 wav aac', FieldConfig::load("media.$type_name.$field_name")->get('settings')['file_extensions']);
+
+    // Check that the display holds the correct formatter configuration.
+    $display = EntityViewDisplay::load("media.$type_name.default");
+    $this->assertInstanceOf(EntityViewDisplay::class, $display);
+    $formatter = $display->getComponent($field_name)['type'];
+    $this->assertSame('file_audio', $formatter);
+
+    // Create a media asset and verify that the <audio> tag is present.
+    file_put_contents('public://file.mp3', str_repeat('t', 10));
+    $file = File::create([
+      'uri' => 'public://file.mp3',
+      'filename' => 'file.mp3',
+    ]);
+    $file->save();
+
+    $this->drupalGet("media/add/$type_name");
+    $page->fillField('Name', 'Audio media asset');
+    $page->attachFileToField("files[{$field_name}_0]", \Drupal::service('file_system')->realpath('public://file.mp3'));
+    $result = $assert_session->waitForButton('Remove');
+    $this->assertNotEmpty($result);
+    $page->pressButton('Save');
+
+    $assert_session->pageTextContains("$type_name Audio media asset has been created.");
+    $assert_session->elementExists('css', "audio > source[type='audio/mpeg']");
+  }
+
+  /**
+   * Check the Video source functionality.
+   */
+  public function testVideoTypeCreation() {
+    $assert_session = $this->assertSession();
+    $page = $this->getSession()->getPage();
+
+    $source_id = 'video_file';
+    $type_name = 'video_type';
+    $field_name = 'field_media_' . $source_id;
+    $this->doTestCreateMediaType($type_name, $source_id);
+
+    // Check that the source field was created with the correct settings.
+    $storage = FieldStorageConfig::load("media.$field_name");
+    $this->assertInstanceOf(FieldStorageConfig::class, $storage);
+    $field = FieldConfig::load("media.$type_name.$field_name");
+    $this->assertInstanceOf(FieldConfig::class, $field);
+    $this->assertSame('mp4', FieldConfig::load("media.$type_name.$field_name")->getSetting('file_extensions'));
+
+    // Check that the display holds the correct formatter configuration.
+    $display = EntityViewDisplay::load("media.$type_name.default");
+    $this->assertInstanceOf(EntityViewDisplay::class, $display);
+    $formatter = $display->getComponent($field_name)['type'];
+    $this->assertSame('file_video', $formatter);
+
+    // Create a media asset and verify that the <video> tag is present.
+    file_put_contents('public://file.mp4', str_repeat('t', 10));
+    $file = File::create([
+      'uri' => 'public://file.mp4',
+      'filename' => 'file.mp4',
+    ]);
+    $file->save();
+
+    $this->drupalGet("media/add/$type_name");
+    $page->fillField('Name', 'Video media asset');
+    $page->attachFileToField("files[{$field_name}_0]", \Drupal::service('file_system')->realpath('public://file.mp4'));
+    $result = $assert_session->waitForButton('Remove');
+    $this->assertNotEmpty($result);
+    $page->pressButton('Save');
+
+    $assert_session->pageTextContains("$type_name Video media asset has been created.");
+    $assert_session->elementExists('css', "video > source[type='video/mp4']");
+  }
+
+}

core/modules/media/tests/src/FunctionalJavascript/MediaSourceFileTest.php

@@ -3,7 +3,7 @@
 namespace Drupal\Tests\media\FunctionalJavascript;
 
 use Drupal\media\Entity\Media;
-use Drupal\media\Entity\MediaType;
+use Drupal\media\Plugin\media\Source\File;
 
 /**
  * Tests the file media source.
@@ -12,33 +12,38 @@ use Drupal\media\Entity\MediaType;
  */
 class MediaSourceFileTest extends MediaSourceTestBase {
 
-  /**
-   * {@inheritdoc}
-   */
-  protected function setUp() {
-    parent::setUp();
-
-    // We need to test without any default configuration in place.
-    // @TODO: Remove this as part of https://www.drupal.org/node/2883813.
-    MediaType::load('file')->delete();
-  }
-
   /**
    * Tests the file media source.
    */
   public function testMediaFileSource() {
     $media_type_id = 'test_media_file_type';
     $source_field_id = 'field_media_file';
+    $provided_fields = [
+      File::METADATA_ATTRIBUTE_SIZE,
+      File::METADATA_ATTRIBUTE_MIME,
+    ];
 
     $session = $this->getSession();
     $page = $session->getPage();
     $assert_session = $this->assertSession();
 
-    $this->doTestCreateMediaType($media_type_id, 'file');
+    $this->doTestCreateMediaType($media_type_id, 'file', $provided_fields);
+
+    // Create custom fields for the media type to store metadata attributes.
+    $fields = [
+      'field_string_file_size' => 'string',
+      'field_string_mime_type' => 'string',
+    ];
+    $this->createMediaTypeFields($fields, $media_type_id);
 
     // Hide the name field widget to test default name generation.
     $this->hideMediaTypeFieldWidget('name', $media_type_id);
 
+    $this->drupalGet("admin/structure/media/manage/{$media_type_id}");
+    $page->selectFieldOption("field_map[" . File::METADATA_ATTRIBUTE_SIZE . "]", 'field_string_file_size');
+    $page->selectFieldOption("field_map[" . File::METADATA_ATTRIBUTE_MIME . "]", 'field_string_mime_type');
+    $page->pressButton('Save');
+
     $test_filename = $this->randomMachineName() . '.txt';
     $test_filepath = 'public://' . $test_filename;
     file_put_contents($test_filepath, $this->randomMachineName());
@@ -62,9 +67,11 @@ class MediaSourceFileTest extends MediaSourceTestBase {
     $page->checkField('revision');
     $assert_session->elementAttributeNotContains('css', '.field--name-revision-log-message', 'style', 'display');
 
-    // Load the media and check if the label was properly populated.
+    // Load the media and check that all the fields are properly populated.
     $media = Media::load(1);
     $this->assertEquals($test_filename, $media->getName());
+    $this->assertEquals('8', $media->get('field_string_file_size')->value);
+    $this->assertEquals('text/plain', $media->get('field_string_mime_type')->value);
 
     // Test the MIME type icon.
     $icon_base = \Drupal::config('media.settings')->get('icon_base_uri');

core/modules/media/tests/src/FunctionalJavascript/MediaSourceImageTest.php

@@ -3,7 +3,6 @@
 namespace Drupal\Tests\media\FunctionalJavascript;
 
 use Drupal\media\Entity\Media;
-use Drupal\media\Entity\MediaType;
 use Drupal\media\Plugin\media\Source\Image;
 
 /**
@@ -13,18 +12,6 @@ use Drupal\media\Plugin\media\Source\Image;
  */
 class MediaSourceImageTest extends MediaSourceTestBase {
 
-  /**
-   * {@inheritdoc}
-   */
-  protected function setUp() {
-    parent::setUp();
-
-    // We need to test without any default configuration in place.
-    // @TODO: Remove this as part of https://www.drupal.org/node/2883813.
-    MediaType::load('file')->delete();
-    MediaType::load('image')->delete();
-  }
-
   /**
    * Tests the image media source.
    */

core/modules/media/tests/src/FunctionalJavascript/MediaTypeCreationTest.php

@@ -2,6 +2,8 @@
 
 namespace Drupal\Tests\media\FunctionalJavascript;
 
+use Drupal\Component\Utility\Html;
+
 /**
  * Tests the media type creation.
  *
@@ -49,6 +51,40 @@ class MediaTypeCreationTest extends MediaJavascriptTestBase {
     $this->drupalGet("admin/structure/media/manage/{$mediaTypeMachineName}");
 
     $assert_session->pageTextContains('Test source field is used to store the essential information about the media item.');
+
+    // Check that the plugin cannot be changed after it is set on type creation.
+    $assert_session->fieldDisabled('Media source');
+    $assert_session->pageTextContains('The media source cannot be changed after the media type is created.');
+
+    // Open up the media add form and verify that the source field is right
+    // after the name, and before the vertical tabs.
+    $this->drupalGet("/media/add/$mediaTypeMachineName");
+
+    // Get the form element, and its HTML representation.
+    $form_selector = '#media-' . Html::cleanCssIdentifier($mediaTypeMachineName) . '-add-form';
+    $form = $assert_session->elementExists('css', $form_selector);
+    $form_html = $form->getOuterHtml();
+
+    // The name field should come before the source field, which should itself
+    // come before the vertical tabs.
+    $name_field = $assert_session->fieldExists('Name', $form)->getOuterHtml();
+    $test_source_field = $assert_session->fieldExists('Test source', $form)->getOuterHtml();
+    $vertical_tabs = $assert_session->elementExists('css', '.vertical-tabs', $form)->getOuterHtml();
+    $date_field = $assert_session->fieldExists('Date', $form)->getOuterHtml();
+    $published_checkbox = $assert_session->fieldExists('Published', $form)->getOuterHtml();
+    $this->assertTrue(strpos($form_html, $test_source_field) > strpos($form_html, $name_field));
+    $this->assertTrue(strpos($form_html, $vertical_tabs) > strpos($form_html, $test_source_field));
+    // The "Published" checkbox should be the last element.
+    $this->assertTrue(strpos($form_html, $published_checkbox) > strpos($form_html, $date_field));
+
+    // Check that a new type with the same machine name cannot be created.
+    $this->drupalGet('admin/structure/media/add');
+    $page->fillField('label', $label);
+    $session->wait(5000, "jQuery('.machine-name-value').text() === '{$mediaTypeMachineName}'");
+    $page->selectFieldOption('Media source', 'test');
+    $assert_session->assertWaitOnAjaxRequest();
+    $page->pressButton('Save');
+    $assert_session->pageTextContains('The machine-readable name is already in use. It must be unique.');
   }
 
   /**

core/modules/media/tests/src/FunctionalJavascript/MediaUiJavascriptTest.php

@@ -38,11 +38,6 @@ class MediaUiJavascriptTest extends MediaJavascriptTestBase {
     parent::setUp();
     $this->drupalPlaceBlock('local_actions_block');
     $this->drupalPlaceBlock('local_tasks_block');
-
-    // We need to test without any default configuration in place.
-    // @TODO: Remove this as part of https://www.drupal.org/node/2883813.
-    MediaType::load('file')->delete();
-    MediaType::load('image')->delete();
   }
 
   /**
@@ -68,6 +63,10 @@ class MediaUiJavascriptTest extends MediaJavascriptTestBase {
     $this->assertJsCondition("jQuery('.form-item-source-configuration-test-config-value').length > 0;");
     $page->fillField('description', $description);
     $page->pressButton('Save');
+    // The wait prevents intermittent test failures.
+    $result = $assert_session->waitForLink('Add media type');
+    $this->assertNotEmpty($result);
+    $assert_session->addressEquals('admin/structure/media');
     $assert_session->pageTextContains('The media type ' . $name . ' has been added.');
     $this->drupalGet('admin/structure/media');
     $assert_session->pageTextContains($name);
@@ -139,6 +138,10 @@ class MediaUiJavascriptTest extends MediaJavascriptTestBase {
     $page->uncheckField('options[status]');
     $page->checkField('options[queue_thumbnail_downloads]');
     $page->pressButton('Save');
+    // The wait prevents intermittent test failures.
+    $result = $assert_session->waitForLink('Add media type');
+    $this->assertNotEmpty($result);
+    $assert_session->addressEquals('admin/structure/media');
     $assert_session->pageTextContains("The media type $new_name has been updated.");
 
     // Test if edit worked and if new field values have been saved as expected.

core/modules/media/tests/src/FunctionalJavascript/MediaViewsWizardTest.php

@@ -22,6 +22,8 @@ class MediaViewsWizardTest extends MediaJavascriptTestBase {
     $page = $session->getPage();
     $assert_session = $this->assertSession();
 
+    $this->createMediaType();
+
     $view_id = strtolower($this->randomMachineName(16));
     $this->drupalGet('admin/structure/views/add');
     $page->fillField('label', $view_id);

core/modules/media/tests/src/Kernel/MediaCreationTest.php

@@ -6,6 +6,8 @@ use Drupal\media\Entity\Media;
 use Drupal\media\Entity\MediaType;
 use Drupal\media\MediaInterface;
 use Drupal\media\MediaTypeInterface;
+use Drupal\user\Entity\Role;
+use Drupal\user\Entity\User;
 
 /**
  * Tests creation of media types and media items.
@@ -33,6 +35,27 @@ class MediaCreationTest extends MediaKernelTestBase {
     // be created automatically when a config is being imported.
     $this->assertEquals(['source_field' => '', 'test_config_value' => 'Kakec'], $test_media_type->get('source_configuration'), 'Could not assure the correct media source configuration.');
     $this->assertEquals(['metadata_attribute' => 'field_attribute_config_test'], $test_media_type->get('field_map'), 'Could not assure the correct field map.');
+    // Check the Media Type access handler behavior.
+    // We grant access to the 'view label' operation to all users having
+    // permission to 'view media'.
+    $user1 = User::create([
+      'name' => 'username1',
+      'status' => 1,
+    ]);
+    $user1->save();
+    $user2 = User::create([
+      'name' => 'username2',
+      'status' => 1,
+    ]);
+    $user2->save();
+    $role = Role::create([
+      'id' => 'role1',
+      'label' => 'role1',
+    ]);
+    $role->grantPermission('view media')->trustData()->save();
+    $user2->addRole($role->id());
+    $this->assertFalse($test_media_type->access('view label', $user1));
+    $this->assertTrue($test_media_type->access('view label', $user2));
   }
 
   /**

core/modules/media/tests/src/Kernel/MediaKernelTestBase.php

@@ -109,7 +109,7 @@ abstract class MediaKernelTestBase extends KernelTestBase {
   }
 
   /**
-   * Helper to generate media entity.
+   * Helper to generate a media item.
    *
    * @param string $filename
    *   String filename with extension.
@@ -117,7 +117,7 @@ abstract class MediaKernelTestBase extends KernelTestBase {
    *   The the media type.
    *
    * @return \Drupal\media\Entity\Media
-   *   A media entity.
+   *   A media item.
    */
   protected function generateMedia($filename, MediaTypeInterface $media_type) {
     vfsStream::setup('drupal_root');

core/modules/media/tests/src/Kernel/MediaLinkRelationsTest.php

@@ -5,7 +5,7 @@ namespace Drupal\Tests\media\Kernel;
 use Drupal\media\Entity\Media;
 
 /**
- * Tests link relationships for Media entity.
+ * Tests link relationships for media items.
  *
  * @group media
  */
@@ -20,7 +20,7 @@ class MediaLinkRelationsTest extends MediaKernelTestBase {
     $media = Media::create(['bundle' => $this->testMediaType->id()]);
     $media->save();
     foreach ($media->uriRelationships() as $relation_name) {
-      $this->assertTrue($link_relation_type_manager->hasDefinition($relation_name), "Link relationship '{$relation_name}' for Media entity");
+      $this->assertTrue($link_relation_type_manager->hasDefinition($relation_name), "Link relationship '{$relation_name}' for a media item");
     }
   }
 

core/modules/media/tests/src/Kernel/MediaSourceFileTest.php

@@ -2,8 +2,6 @@
 
 namespace Drupal\Tests\media\Kernel;
 
-use Drupal\media\Entity\MediaType;
-
 /**
  * Tests the file media source.
  *
@@ -11,18 +9,6 @@ use Drupal\media\Entity\MediaType;
  */
 class MediaSourceFileTest extends MediaKernelTestBase {
 
-  /**
-   * {@inheritdoc}
-   */
-  protected function setUp() {
-    parent::setUp();
-
-    // We need to test without any default configuration in place.
-    // @TODO: Remove this as part of https://www.drupal.org/node/2883813.
-    MediaType::load('file')->delete();
-    MediaType::load('image')->delete();
-  }
-
   /**
    * Tests the file extension constraint.
    */

core/modules/media/tests/src/Kernel/MediaSourceTest.php

@@ -140,6 +140,20 @@ class MediaSourceTest extends MediaKernelTestBase {
     $this->assertEquals('Snowball', $media->get($field_name)->value, 'Metadata attribute was not mapped to the field.');
   }
 
+  /**
+   * Tests the getSourceFieldValue() method.
+   */
+  public function testGetSourceFieldValue() {
+    /** @var \Drupal\media\MediaInterface $media */
+    $media = Media::create([
+      'bundle' => $this->testMediaType->id(),
+      'field_media_test' => 'some_value',
+    ]);
+    $media->save();
+    $media_source = $media->getSource();
+    $this->assertSame('some_value', $media_source->getSourceFieldValue($media));
+  }
+
   /**
    * Tests the thumbnail functionality.
    */
@@ -147,7 +161,7 @@ class MediaSourceTest extends MediaKernelTestBase {
     file_put_contents('public://thumbnail1.jpg', '');
     file_put_contents('public://thumbnail2.jpg', '');
 
-    // Save a media entity and make sure thumbnail was added.
+    // Save a media item and make sure thumbnail was added.
     \Drupal::state()->set('media_source_test_attributes', [
       'thumbnail_uri' => ['title' => 'Thumbnail', 'value' => 'public://thumbnail1.jpg'],
     ]);
@@ -160,7 +174,7 @@ class MediaSourceTest extends MediaKernelTestBase {
     $media_source = $media->getSource();
     $this->assertEquals('public://thumbnail1.jpg', $media_source->getMetadata($media, 'thumbnail_uri'), 'Value of the thumbnail metadata attribute is not correct.');
     $media->save();
-    $this->assertEquals('public://thumbnail1.jpg', $media->thumbnail->entity->getFileUri(), 'Thumbnail was not added to the media entity.');
+    $this->assertEquals('public://thumbnail1.jpg', $media->thumbnail->entity->getFileUri(), 'Thumbnail was not added to the media item.');
     $this->assertEquals('Mr. Jones', $media->thumbnail->title, 'Title text was not set on the thumbnail.');
     $this->assertEquals('Thumbnail', $media->thumbnail->alt, 'Alt text was not set on the thumbnail.');
 
@@ -179,7 +193,7 @@ class MediaSourceTest extends MediaKernelTestBase {
     $media->thumbnail->target_id = NULL;
     $this->assertEquals('public://thumbnail2.jpg', $media_source->getMetadata($media, 'thumbnail_uri'), 'Value of the thumbnail metadata attribute is not correct.');
     $media->save();
-    $this->assertEquals('public://thumbnail2.jpg', $media->thumbnail->entity->getFileUri(), 'New thumbnail was not added to the media entity.');
+    $this->assertEquals('public://thumbnail2.jpg', $media->thumbnail->entity->getFileUri(), 'New thumbnail was not added to the media item.');
     $this->assertEquals('Mr. Jones', $media->thumbnail->title, 'Title text was not set on the thumbnail.');
     $this->assertEquals('Thumbnail', $media->thumbnail->alt, 'Alt text was not set on the thumbnail.');
 
@@ -191,7 +205,7 @@ class MediaSourceTest extends MediaKernelTestBase {
     $media->field_media_test->value = 'some_new_value';
     $this->assertEquals('public://thumbnail1.jpg', $media_source->getMetadata($media, 'thumbnail_uri'), 'Value of the thumbnail metadata attribute is not correct.');
     $media->save();
-    $this->assertEquals('public://thumbnail1.jpg', $media->thumbnail->entity->getFileUri(), 'New thumbnail was not added to the media entity.');
+    $this->assertEquals('public://thumbnail1.jpg', $media->thumbnail->entity->getFileUri(), 'New thumbnail was not added to the media item.');
     $this->assertEquals('Mr. Jones', $media->thumbnail->title, 'Title text was not set on the thumbnail.');
     $this->assertEquals('Thumbnail', $media->thumbnail->alt, 'Alt text was not set on the thumbnail.');
 
@@ -268,13 +282,13 @@ class MediaSourceTest extends MediaKernelTestBase {
       'field_media_test' => 'some_value',
     ]);
     $media->save();
-    $this->assertEquals('Boxer', $media->getName(), 'Correct name was not set on the media entity.');
+    $this->assertEquals('Boxer', $media->getName(), 'Correct name was not set on the media item.');
     $this->assertEquals('This will be title.', $media->thumbnail->title, 'Title text was not set on the thumbnail.');
     $this->assertEquals('This will be alt.', $media->thumbnail->alt, 'Alt text was not set on the thumbnail.');
   }
 
   /**
-   * Tests the media entity constraints functionality.
+   * Tests the media item constraints functionality.
    */
   public function testConstraints() {
     // Test entity constraints.
@@ -442,4 +456,79 @@ class MediaSourceTest extends MediaKernelTestBase {
     $this->assertEquals($expected, $source->getConfiguration(), 'Submitted values were saved correctly.');
   }
 
+  /**
+   * Tests different display options for the source field.
+   */
+  public function testDifferentSourceFieldDisplays() {
+    $id = 'test_different_displays';
+    $field_name = 'field_media_different_display';
+
+    $this->createMediaTypeViaForm($id, $field_name);
+
+    // Source field not in displays.
+    $display = entity_get_display('media', $id, 'default');
+    $components = $display->getComponents();
+    $this->assertArrayHasKey($field_name, $components);
+    $this->assertSame('entity_reference_entity_id', $components[$field_name]['type']);
+
+    $display = entity_get_form_display('media', $id, 'default');
+    $components = $display->getComponents();
+    $this->assertArrayHasKey($field_name, $components);
+    $this->assertSame('entity_reference_autocomplete_tags', $components[$field_name]['type']);
+  }
+
+  /**
+   * Tests hidden source field in media type.
+   */
+  public function testHiddenSourceField() {
+    $id = 'test_hidden_source_field';
+    $field_name = 'field_media_hidden';
+
+    $this->createMediaTypeViaForm($id, $field_name);
+
+    // Source field not in displays.
+    $display = entity_get_display('media', $id, 'default');
+    $this->assertArrayNotHasKey($field_name, $display->getComponents());
+
+    $display = entity_get_form_display('media', $id, 'default');
+    $this->assertArrayNotHasKey($field_name, $display->getComponents());
+  }
+
+  /**
+   * Creates a media type via form submit.
+   *
+   * @param string $source_plugin_id
+   *   Source plugin ID.
+   * @param string $field_name
+   *   Source field name.
+   */
+  protected function createMediaTypeViaForm($source_plugin_id, $field_name) {
+    /** @var \Drupal\media\MediaTypeInterface $type */
+    $type = MediaType::create(['source' => $source_plugin_id]);
+
+    $form = $this->container->get('entity_type.manager')
+      ->getFormObject('media_type', 'add')
+      ->setEntity($type);
+
+    $form_state = new FormState();
+    $form_state->setValues([
+      'label' => 'Test type',
+      'id' => $source_plugin_id,
+      'op' => t('Save'),
+    ]);
+
+    /** @var \Drupal\Core\Entity\EntityFieldManagerInterface $field_manager */
+    $field_manager = \Drupal::service('entity_field.manager');
+
+    // Source field not created yet.
+    $fields = $field_manager->getFieldDefinitions('media', $source_plugin_id);
+    $this->assertArrayNotHasKey($field_name, $fields);
+
+    \Drupal::formBuilder()->submitForm($form, $form_state);
+
+    // Source field exists now.
+    $fields = $field_manager->getFieldDefinitions('media', $source_plugin_id);
+    $this->assertArrayHasKey($field_name, $fields);
+  }
+
 }

core/modules/media/tests/src/Kernel/MediaTest.php

@@ -12,7 +12,7 @@ use Drupal\media\Entity\Media;
 class MediaTest extends MediaKernelTestBase {
 
   /**
-   * Tests various aspects of a Media entity.
+   * Tests various aspects of a media item.
    */
   public function testEntity() {
     $media = Media::create(['bundle' => $this->testMediaType->id()]);
@@ -21,14 +21,17 @@ class MediaTest extends MediaKernelTestBase {
   }
 
   /**
-   * Ensure media name is configurable on manage display.
+   * Tests the Media "name" base field behavior.
    */
-  public function testNameIsConfigurable() {
+  public function testNameBaseField() {
     /** @var \Drupal\Core\Field\BaseFieldDefinition[] $field_definitions */
     $field_definitions = $this->container->get('entity_field.manager')
       ->getBaseFieldDefinitions('media');
 
+    // Ensure media name is configurable on manage display.
     $this->assertTrue($field_definitions['name']->isDisplayConfigurable('view'));
+    // Ensure it is not visible by default.
+    $this->assertEquals($field_definitions['name']->getDisplayOptions('view'), ['region' => 'hidden']);
   }
 
 }