Move into nested docroot

web/core/modules/rdf/src/CommonDataConverter.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Drupal\rdf;
+
+/**
+ * Contains methods for common data conversions.
+ */
+class CommonDataConverter {
+
+  /**
+   * Provides a passthrough to place unformatted values in content attributes.
+   *
+   * @param mixed $data
+   *   The data to be placed in the content attribute.
+   *
+   * @return mixed
+   *   Returns the data.
+   */
+  public static function rawValue($data) {
+    return $data;
+  }
+
+  /**
+   * Converts a date entity field array into an ISO 8601 timestamp string.
+   *
+   * @param array $data
+   *   The array containing the 'value' element.
+   *
+   * @return string
+   *   Returns the ISO 8601 timestamp.
+   */
+  public static function dateIso8601Value($data) {
+    return \Drupal::service('date.formatter')->format($data['value'], 'custom', 'c', 'UTC');
+  }
+
+}

web/core/modules/rdf/src/Entity/RdfMapping.php

@@ -0,0 +1,160 @@
+<?php
+
+namespace Drupal\rdf\Entity;
+
+use Drupal\Core\Config\Entity\ConfigEntityBase;
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\rdf\RdfMappingInterface;
+
+/**
+ * Config entity for working with RDF mappings.
+ *
+ * @ConfigEntityType(
+ *   id = "rdf_mapping",
+ *   label = @Translation("RDF mapping"),
+ *   config_prefix = "mapping",
+ *   entity_keys = {
+ *     "id" = "id"
+ *   },
+ *   config_export = {
+ *     "id",
+ *     "targetEntityType",
+ *     "bundle",
+ *     "types",
+ *     "fieldMappings",
+ *   }
+ * )
+ */
+class RdfMapping extends ConfigEntityBase implements RdfMappingInterface {
+
+  /**
+   * Unique ID for the config entity.
+   *
+   * @var string
+   */
+  protected $id;
+
+  /**
+   * Entity type to be mapped.
+   *
+   * @var string
+   */
+  protected $targetEntityType;
+
+  /**
+   * Bundle to be mapped.
+   *
+   * @var string
+   */
+  protected $bundle;
+
+  /**
+   * The RDF type mapping for this bundle.
+   *
+   * @var array
+   */
+  protected $types = array();
+
+  /**
+   * The mappings for fields on this bundle.
+   *
+   * @var array
+   */
+  protected $fieldMappings = array();
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPreparedBundleMapping() {
+    return array('types' => $this->types);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getBundleMapping() {
+    if (!empty($this->types)) {
+      return array('types' => $this->types);
+    }
+    return array();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setBundleMapping(array $mapping) {
+    if (isset($mapping['types'])) {
+      $this->types = $mapping['types'];
+    }
+
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPreparedFieldMapping($field_name) {
+    $field_mapping = array(
+      'properties' => NULL,
+      'datatype' => NULL,
+      'datatype_callback' => NULL,
+      'mapping_type' => NULL,
+    );
+    if (isset($this->fieldMappings[$field_name])) {
+      $field_mapping = array_merge($field_mapping, $this->fieldMappings[$field_name]);
+    }
+    return empty($field_mapping['properties']) ? array() : $field_mapping;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFieldMapping($field_name) {
+    if (isset($this->fieldMappings[$field_name])) {
+      return $this->fieldMappings[$field_name];
+    }
+    return array();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setFieldMapping($field_name, array $mapping = array()) {
+    $this->fieldMappings[$field_name] = $mapping;
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function id() {
+    return $this->targetEntityType . '.' . $this->bundle;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    parent::calculateDependencies();
+
+    // Create dependency on the bundle.
+    $entity_type = \Drupal::entityManager()->getDefinition($this->targetEntityType);
+    $this->addDependency('module', $entity_type->getProvider());
+    $bundle_config_dependency = $entity_type->getBundleConfigDependency($this->bundle);
+    $this->addDependency($bundle_config_dependency['type'], $bundle_config_dependency['name']);
+
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function postSave(EntityStorageInterface $storage, $update = TRUE) {
+    parent::postSave($storage, $update);
+
+    if (\Drupal::entityManager()->hasHandler($this->targetEntityType, 'view_builder')) {
+      \Drupal::entityManager()->getViewBuilder($this->targetEntityType)->resetCache();
+    }
+  }
+
+}

web/core/modules/rdf/src/RdfMappingInterface.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace Drupal\rdf;
+
+use Drupal\Core\Config\Entity\ConfigEntityInterface;
+
+/**
+ * Provides an interface defining an RDF mapping entity.
+ */
+interface RdfMappingInterface extends ConfigEntityInterface {
+
+  /**
+   * Gets the mapping for the bundle-level data.
+   *
+   * The prepared bundle mapping should be used when outputting data in RDF
+   * serializations such as RDFa. In the prepared mapping, the mapping
+   * configuration's CURIE arrays are processed into CURIE strings suitable for
+   * output.
+   *
+   * @return array
+   *   The bundle mapping.
+   */
+  public function getPreparedBundleMapping();
+
+  /**
+   * Gets the mapping config for the bundle-level data.
+   *
+   * This function returns the bundle mapping as stored in config, which may
+   * contain CURIE arrays. If the mapping is needed for output in a
+   * serialization format, such as RDFa, then getPreparedBundleMapping() should
+   * be used instead.
+   *
+   * @return array
+   *   The bundle mapping, or an empty array if there is no mapping.
+   */
+  public function getBundleMapping();
+
+  /**
+   * Sets the mapping config for the bundle-level data.
+   *
+   * This only sets bundle-level mappings, such as the RDF type. Mappings for
+   * a bundle's fields should be handled with setFieldMapping.
+   *
+   * Example usage:
+   * -Map the 'article' bundle to 'sioc:Post'.
+   * @code
+   * rdf_get_mapping('node', 'article')
+   *   ->setBundleMapping(array(
+   *     'types' => array('sioc:Post'),
+   *   ))
+   *   ->save();
+   * @endcode
+   *
+   * @param array $mapping
+   *   The bundle mapping.
+   *
+   * @return \Drupal\rdf\Entity\RdfMapping
+   *   The RdfMapping object.
+   */
+  public function setBundleMapping(array $mapping);
+
+  /**
+   * Gets the prepared mapping for a field.
+   *
+   * The prepared field mapping should be used when outputting data in RDF
+   * serializations such as RDFa. In the prepared mapping, the mapping
+   * configuration's CURIE arrays are processed into CURIE strings suitable for
+   * output.
+   *
+   * @param string $field_name
+   *   The name of the field.
+   *
+   * @return array
+   *   The prepared field mapping, or an empty array if there is no mapping.
+   */
+  public function getPreparedFieldMapping($field_name);
+
+  /**
+   * Gets the mapping config for a field.
+   *
+   * This function returns the field mapping as stored in config, which may
+   * contain CURIE arrays. If the mapping is needed for output in a
+   * serialization format, such as RDFa, then getPreparedFieldMapping() should
+   * be used instead.
+   *
+   * @param string $field_name
+   *   The name of the field.
+   *
+   * @return array
+   *   The field mapping config array, or an empty array if there is no mapping.
+   */
+  public function getFieldMapping($field_name);
+
+  /**
+   * Sets the mapping config for a field.
+   *
+   * @param string $field_name
+   *   The name of the field.
+   * @param array $mapping
+   *   The field mapping.
+   *
+   * @return \Drupal\rdf\Entity\RdfMapping
+   *   The RdfMapping object.
+   */
+  public function setFieldMapping($field_name, array $mapping = array());
+
+}

web/core/modules/rdf/src/SchemaOrgDataConverter.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Drupal\rdf;
+
+class SchemaOrgDataConverter {
+
+  /**
+   * Converts an interaction count to a string with the interaction type.
+   *
+   * Schema.org defines a number of different interaction types.
+   *
+   * @param int $count
+   *   The interaction count.
+   * @param array $arguments
+   *   An array of arguments defined in the mapping.
+   *   Expected keys are:
+   *     - interaction_type: The string to use for the type of interaction
+   *       (e.g. UserComments).
+   *
+   * @return string
+   *   The formatted string.
+   *
+   * @see http://schema.org/UserInteraction
+   */
+  static function interactionCount($count, $arguments) {
+    $interaction_type = $arguments['interaction_type'];
+    return "$interaction_type:$count";
+  }
+
+}

web/core/modules/rdf/src/Tests/CommentAttributesTest.php

@@ -0,0 +1,376 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\comment\CommentInterface;
+use Drupal\comment\CommentManagerInterface;
+use Drupal\comment\Tests\CommentTestBase;
+use Drupal\user\RoleInterface;
+use Drupal\comment\Entity\Comment;
+
+/**
+ * Tests the RDFa markup of comments.
+ *
+ * @group rdf
+ */
+class CommentAttributesTest extends CommentTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('views', 'node', 'comment', 'rdf');
+
+  /**
+   * URI of the front page of the Drupal site.
+   *
+   * @var string
+   */
+  protected $baseUri;
+
+  /**
+   * URI of the test node created by CommentTestBase::setUp().
+   *
+   * @var string
+   */
+  protected $nodeUri;
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Enables anonymous user comments.
+    user_role_change_permissions(RoleInterface::ANONYMOUS_ID, array(
+      'access comments' => TRUE,
+      'post comments' => TRUE,
+      'skip comment approval' => TRUE,
+    ));
+    // Allows anonymous to leave their contact information.
+    $this->setCommentAnonymous(COMMENT_ANONYMOUS_MAY_CONTACT);
+    $this->setCommentPreview(DRUPAL_OPTIONAL);
+    $this->setCommentForm(TRUE);
+    $this->setCommentSubject(TRUE);
+    $this->setCommentSettings('comment_default_mode', CommentManagerInterface::COMMENT_MODE_THREADED, 'Comment paging changed.');
+
+    // Prepares commonly used URIs.
+    $this->baseUri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+    $this->nodeUri = $this->node->url('canonical', ['absolute' => TRUE]);
+
+    // Set relation between node and comment.
+    $article_mapping = rdf_get_mapping('node', 'article');
+    $comment_count_mapping = array(
+      'properties' => array('sioc:num_replies'),
+      'datatype' => 'xsd:integer',
+      'datatype_callback' => array('callable' => 'Drupal\rdf\CommonDataConverter::rawValue'),
+    );
+    $article_mapping->setFieldMapping('comment_count', $comment_count_mapping)->save();
+
+    // Save user mapping.
+    $user_mapping = rdf_get_mapping('user', 'user');
+    $username_mapping = array(
+      'properties' => array('foaf:name'),
+    );
+    $user_mapping->setFieldMapping('name', $username_mapping)->save();
+    $user_mapping->setFieldMapping('homepage', array('properties' => array('foaf:page'), 'mapping_type' => 'rel'))->save();
+
+    // Save comment mapping.
+    $mapping = rdf_get_mapping('comment', 'comment');
+    $mapping->setBundleMapping(array('types' => array('sioc:Post', 'sioct:Comment')))->save();
+    $field_mappings = array(
+      'subject' => array(
+        'properties' => array('dc:title'),
+      ),
+      'created' => array(
+        'properties' => array('dc:date', 'dc:created'),
+        'datatype' => 'xsd:dateTime',
+        'datatype_callback' => array('callable' => 'Drupal\rdf\CommonDataConverter::dateIso8601Value'),
+      ),
+      'changed' => array(
+        'properties' => array('dc:modified'),
+        'datatype' => 'xsd:dateTime',
+        'datatype_callback' => array('callable' => 'Drupal\rdf\CommonDataConverter::dateIso8601Value'),
+      ),
+      'comment_body' => array(
+        'properties' => array('content:encoded'),
+      ),
+      'pid' => array(
+        'properties' => array('sioc:reply_of'),
+        'mapping_type' => 'rel',
+      ),
+      'uid' => array(
+        'properties' => array('sioc:has_creator'),
+        'mapping_type' => 'rel',
+      ),
+      'name' => array(
+        'properties' => array('foaf:name'),
+      ),
+    );
+    // Iterate over shared field mappings and save.
+    foreach ($field_mappings as $field_name => $field_mapping) {
+      $mapping->setFieldMapping($field_name, $field_mapping)->save();
+    }
+  }
+
+  /**
+   * Tests the presence of the RDFa markup for the number of comments.
+   */
+  public function testNumberOfCommentsRdfaMarkup() {
+    // Posts 2 comments on behalf of registered user.
+    $this->saveComment($this->node->id(), $this->webUser->id());
+    $this->saveComment($this->node->id(), $this->webUser->id());
+
+    // Tests number of comments in teaser view.
+    $this->drupalLogin($this->webUser);
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node'), 'rdfa', $this->baseUri);
+
+    // Number of comments.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => 2,
+      'datatype' => 'http://www.w3.org/2001/XMLSchema#integer',
+    );
+    $this->assertTrue($graph->hasProperty($this->nodeUri, 'http://rdfs.org/sioc/ns#num_replies', $expected_value), 'Number of comments found in RDF output of teaser view (sioc:num_replies).');
+
+    // Tests number of comments in full node view, expected value is the same.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $this->node->id()), 'rdfa', $this->baseUri);
+    $this->assertTrue($graph->hasProperty($this->nodeUri, 'http://rdfs.org/sioc/ns#num_replies', $expected_value), 'Number of comments found in RDF output of full node view mode (sioc:num_replies).');
+  }
+
+  /**
+   * Tests comment author link markup has not been broken by RDF.
+   */
+  public function testCommentRdfAuthorMarkup() {
+    // Post a comment as a registered user.
+    $this->saveComment($this->node->id(), $this->webUser->id());
+
+    // Give the user access to view user profiles so the profile link shows up.
+    user_role_grant_permissions(RoleInterface::AUTHENTICATED_ID, ['access user profiles']);
+    $this->drupalLogin($this->webUser);
+
+    // Ensure that the author link still works properly after the author output
+    // is modified by the RDF module.
+    $this->drupalGet('node/' . $this->node->id());
+    $this->assertLink($this->webUser->getUsername());
+    $this->assertLinkByHref('user/' . $this->webUser->id());
+  }
+
+  /**
+   * Tests if RDFa markup for meta information is present in comments.
+   *
+   * Tests presence of RDFa markup for the title, date and author and homepage
+   * on comments from registered and anonymous users.
+   */
+  public function testCommentRdfaMarkup() {
+    // Posts comment #1 on behalf of registered user.
+    $comment1 = $this->saveComment($this->node->id(), $this->webUser->id());
+
+    // Tests comment #1 with access to the user profile.
+    $this->drupalLogin($this->webUser);
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $this->node->id()), 'rdfa', $this->baseUri);
+    $this->_testBasicCommentRdfaMarkup($graph, $comment1);
+
+    // Tests comment #1 with no access to the user profile (as anonymous user).
+    $this->drupalLogout();
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $this->node->id()), 'rdfa', $this->baseUri);
+    $this->_testBasicCommentRdfaMarkup($graph, $comment1);
+
+    // Posts comment #2 as anonymous user.
+    $anonymous_user = array();
+    $anonymous_user['name'] = $this->randomMachineName();
+    $anonymous_user['mail'] = 'tester@simpletest.org';
+    $anonymous_user['homepage'] = 'http://example.org/';
+    $comment2 = $this->saveComment($this->node->id(), 0, $anonymous_user);
+
+    // Tests comment #2 as anonymous user.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $this->node->id()), 'rdfa', $this->baseUri);
+    $this->_testBasicCommentRdfaMarkup($graph, $comment2, $anonymous_user);
+
+    // Tests comment #2 as logged in user.
+    $this->drupalLogin($this->webUser);
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $this->node->id()), 'rdfa', $this->baseUri);
+    $this->_testBasicCommentRdfaMarkup($graph, $comment2, $anonymous_user);
+  }
+
+  /**
+   * Tests RDF comment replies.
+   */
+  public function testCommentReplyOfRdfaMarkup() {
+    // Posts comment #1 on behalf of registered user.
+    $this->drupalLogin($this->webUser);
+    $comment_1 = $this->saveComment($this->node->id(), $this->webUser->id());
+
+    $comment_1_uri = $comment_1->url('canonical', ['absolute' => TRUE]);
+
+    // Posts a reply to the first comment.
+    $comment_2 = $this->saveComment($this->node->id(), $this->webUser->id(), NULL, $comment_1->id());
+    $comment_2_uri = $comment_2->url('canonical', ['absolute' => TRUE]);
+
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $this->node->id()), 'rdfa', $this->baseUri);
+
+    // Tests the reply_of relationship of a first level comment.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->nodeUri,
+    );
+    $this->assertTrue($graph->hasProperty($comment_1_uri, 'http://rdfs.org/sioc/ns#reply_of', $expected_value), 'Comment relation to its node found in RDF output (sioc:reply_of).');
+
+    // Tests the reply_of relationship of a second level comment.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->nodeUri,
+    );
+    $this->assertTrue($graph->hasProperty($comment_2_uri, 'http://rdfs.org/sioc/ns#reply_of', $expected_value), 'Comment relation to its node found in RDF output (sioc:reply_of).');
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $comment_1_uri,
+    );
+    $this->assertTrue($graph->hasProperty($comment_2_uri, 'http://rdfs.org/sioc/ns#reply_of', $expected_value), 'Comment relation to its parent comment found in RDF output (sioc:reply_of).');
+  }
+
+  /**
+   * Helper function for testCommentRdfaMarkup().
+   *
+   * Tests the current page for basic comment RDFa markup.
+   *
+   * @param $comment
+   *   Comment object.
+   * @param $account
+   *   An array containing information about an anonymous user.
+   */
+  function _testBasicCommentRdfaMarkup($graph, CommentInterface $comment, $account = array()) {
+    $comment_uri = $comment->url('canonical', array('absolute' => TRUE));
+
+    // Comment type.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://rdfs.org/sioc/types#Comment',
+    );
+    $this->assertTrue($graph->hasProperty($comment_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Comment type found in RDF output (sioct:Comment).');
+    // Comment type.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://rdfs.org/sioc/ns#Post',
+    );
+    $this->assertTrue($graph->hasProperty($comment_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Comment type found in RDF output (sioc:Post).');
+
+    // Comment title.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $comment->getSubject(),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($comment_uri, 'http://purl.org/dc/terms/title', $expected_value), 'Comment subject found in RDF output (dc:title).');
+
+    // Comment date.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => format_date($comment->getCreatedTime(), 'custom', 'c', 'UTC'),
+      'datatype' => 'http://www.w3.org/2001/XMLSchema#dateTime',
+    );
+    $this->assertTrue($graph->hasProperty($comment_uri, 'http://purl.org/dc/terms/date', $expected_value), 'Comment date found in RDF output (dc:date).');
+    // Comment date.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => format_date($comment->getCreatedTime(), 'custom', 'c', 'UTC'),
+      'datatype' => 'http://www.w3.org/2001/XMLSchema#dateTime',
+    );
+    $this->assertTrue($graph->hasProperty($comment_uri, 'http://purl.org/dc/terms/created', $expected_value), 'Comment date found in RDF output (dc:created).');
+
+    // Comment body.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $comment->comment_body->value . "\n",
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($comment_uri, 'http://purl.org/rss/1.0/modules/content/encoded', $expected_value), 'Comment body found in RDF output (content:encoded).');
+
+    // The comment author can be a registered user or an anonymous user.
+    if ($comment->getOwnerId() > 0) {
+      $author_uri = \Drupal::url('entity.user.canonical', ['user' => $comment->getOwnerId()], array('absolute' => TRUE));
+      // Comment relation to author.
+      $expected_value = array(
+        'type' => 'uri',
+        'value' => $author_uri,
+      );
+      $this->assertTrue($graph->hasProperty($comment_uri, 'http://rdfs.org/sioc/ns#has_creator', $expected_value), 'Comment relation to author found in RDF output (sioc:has_creator).');
+    }
+    else {
+      // The author is expected to be a blank node.
+      $author_uri = $graph->get($comment_uri, '<http://rdfs.org/sioc/ns#has_creator>');
+      if ($author_uri instanceof \EasyRdf_Resource) {
+        $this->assertTrue($author_uri->isBnode(), 'Comment relation to author found in RDF output (sioc:has_creator) and author is blank node.');
+      }
+      else {
+        $this->fail('Comment relation to author found in RDF output (sioc:has_creator).');
+      }
+    }
+
+    // Author name.
+    $name = empty($account["name"]) ? $this->webUser->getUsername() : $account["name"] . " (not verified)";
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $name,
+    );
+    $this->assertTrue($graph->hasProperty($author_uri, 'http://xmlns.com/foaf/0.1/name', $expected_value), 'Comment author name found in RDF output (foaf:name).');
+
+    // Comment author homepage (only for anonymous authors).
+    if ($comment->getOwnerId() == 0) {
+      $expected_value = array(
+        'type' => 'uri',
+        'value' => 'http://example.org/',
+      );
+      $this->assertTrue($graph->hasProperty($author_uri, 'http://xmlns.com/foaf/0.1/page', $expected_value), 'Comment author link found in RDF output (foaf:page).');
+    }
+  }
+
+  /**
+   * Creates a comment entity.
+   *
+   * @param $nid
+   *   Node id which will hold the comment.
+   * @param $uid
+   *   User id of the author of the comment. Can be NULL if $contact provided.
+   * @param $contact
+   *   Set to NULL for no contact info, TRUE to ignore success checking, and
+   *   array of values to set contact info.
+   * @param $pid
+   *   Comment id of the parent comment in a thread.
+   *
+   * @return \Drupal\comment\Entity\Comment
+   *   The saved comment.
+   */
+  function saveComment($nid, $uid, $contact = NULL, $pid = 0) {
+    $values = array(
+      'entity_id' => $nid,
+      'entity_type' => 'node',
+      'field_name' => 'comment',
+      'uid' => $uid,
+      'pid' => $pid,
+      'subject' => $this->randomMachineName(),
+      'comment_body' => $this->randomMachineName(),
+      'status' => 1,
+    );
+    if ($contact) {
+      $values += $contact;
+    }
+
+    $comment = Comment::create($values);
+    $comment->save();
+    return $comment;
+  }
+
+}

web/core/modules/rdf/src/Tests/EntityReferenceFieldAttributesTest.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\taxonomy\Tests\TaxonomyTestBase;
+
+/**
+ * Tests RDFa markup generation for taxonomy term fields.
+ *
+ * @group rdf
+ */
+class EntityReferenceFieldAttributesTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'field_test', 'file', 'image');
+
+  /**
+   * The name of the taxonomy term reference field used in the test.
+   *
+   * @var string
+   */
+  protected $fieldName;
+
+  /**
+   * The vocabulary object used in the test.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  protected function setUp() {
+    parent::setUp();
+
+    $web_user = $this->drupalCreateUser(array('bypass node access', 'administer taxonomy'));
+    $this->drupalLogin($web_user);
+    $this->vocabulary = $this->createVocabulary();
+
+    // Create the field.
+    $this->fieldName = 'field_taxonomy_test';
+    $handler_settings = array(
+      'target_bundles' => array(
+        $this->vocabulary->id() => $this->vocabulary->id(),
+      ),
+      'auto_create' => TRUE,
+    );
+    $this->createEntityReferenceField('node', 'article', $this->fieldName, 'Tags', 'taxonomy_term', 'default', $handler_settings, FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+
+    entity_get_form_display('node', 'article', 'default')
+      ->setComponent($this->fieldName, array('type' => 'options_select'))
+      ->save();
+    entity_get_display('node', 'article', 'full')
+      ->setComponent($this->fieldName, array('type' => 'entity_reference_label'))
+      ->save();
+
+    // Set the RDF mapping for the new field.
+    rdf_get_mapping('node', 'article')
+      ->setFieldMapping($this->fieldName, array(
+        'properties' => array('dc:subject'),
+        'mapping_type' => 'rel',
+      ))
+      ->save();
+
+    rdf_get_mapping('taxonomy_term', $this->vocabulary->id())
+      ->setBundleMapping(array('types' => array('skos:Concept')))
+      ->setFieldMapping('name', array('properties' => array('rdfs:label')))
+      ->save();
+  }
+
+  /**
+   * Tests if file fields in teasers have correct resources.
+   *
+   * Ensure that file fields have the correct resource as the object in RDFa
+   * when displayed as a teaser.
+   */
+  function testNodeTeaser() {
+    // Set the teaser display to show this field.
+    entity_get_display('node', 'article', 'teaser')
+      ->setComponent($this->fieldName, array('type' => 'entity_reference_label'))
+      ->save();
+
+    // Create a term in each vocabulary.
+    $term1 = $this->createTerm($this->vocabulary);
+    $term2 = $this->createTerm($this->vocabulary);
+    $taxonomy_term_1_uri = $term1->url('canonical', ['absolute' => TRUE]);
+    $taxonomy_term_2_uri = $term2->url('canonical', ['absolute' => TRUE]);
+
+    // Create the node.
+    $node = $this->drupalCreateNode(array('type' => 'article'));
+    $node->set($this->fieldName, array(
+      array('target_id' => $term1->id()),
+      array('target_id' => $term2->id()),
+    ));
+
+    // Render the node.
+    $node_render_array = entity_view_multiple(array($node), 'teaser');
+    $html = \Drupal::service('renderer')->renderRoot($node_render_array);
+
+    // Parse the teaser.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+    $parser->parse($graph, $html, 'rdfa', $base_uri);
+
+    // Node relations to taxonomy terms.
+    $node_uri = $node->url('canonical', ['absolute' => TRUE]);
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $taxonomy_term_1_uri,
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://purl.org/dc/terms/subject', $expected_value), 'Node to term relation found in RDF output (dc:subject).');
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $taxonomy_term_2_uri,
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://purl.org/dc/terms/subject', $expected_value), 'Node to term relation found in RDF output (dc:subject).');
+    // Taxonomy terms triples.
+    // Term 1.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://www.w3.org/2004/02/skos/core#Concept',
+    );
+    // @todo Enable with https://www.drupal.org/node/2072791.
+    //$this->assertTrue($graph->hasProperty($taxonomy_term_1_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Taxonomy term type found in RDF output (skos:Concept).');
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $term1->getName(),
+    );
+    //$this->assertTrue($graph->hasProperty($taxonomy_term_1_uri, 'http://www.w3.org/2000/01/rdf-schema#label', $expected_value), 'Taxonomy term name found in RDF output (rdfs:label).');
+    // Term 2.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://www.w3.org/2004/02/skos/core#Concept',
+    );
+    //$this->assertTrue($graph->hasProperty($taxonomy_term_2_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Taxonomy term type found in RDF output (skos:Concept).');
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $term2->getName(),
+    );
+    //$this->assertTrue($graph->hasProperty($taxonomy_term_2_uri, 'http://www.w3.org/2000/01/rdf-schema#label', $expected_value), 'Taxonomy term name found in RDF output (rdfs:label).');
+  }
+
+}

web/core/modules/rdf/src/Tests/Field/TestDataConverter.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Drupal\rdf\Tests\Field;
+
+/**
+ * Contains methods for test data conversions.
+ */
+class TestDataConverter {
+
+  /**
+   * Converts data into a string for placement into a content attribute.
+   *
+   * @param array $data
+   *   The data to be altered and placed in the content attribute.
+   *
+   * @return string
+   *   Returns the data.
+   */
+  static function convertFoo($data) {
+    return 'foo' . $data['value'];
+  }
+
+}

web/core/modules/rdf/src/Tests/FileFieldAttributesTest.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\file\Tests\FileFieldTestBase;
+use Drupal\file\Entity\File;
+
+/**
+ * Tests the RDFa markup of filefields.
+ *
+ * @group rdf
+ */
+class FileFieldAttributesTest extends FileFieldTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'file');
+
+  /**
+   * The name of the file field used in the test.
+   *
+   * @var string
+   */
+  protected $fieldName;
+
+  /**
+   * The file object used in the test.
+   *
+   * @var \Drupal\file\FileInterface
+   */
+  protected $file;
+
+  /**
+   * The node object used in the test.
+   *
+   * @var \Drupal\node\NodeInterface
+   */
+  protected $node;
+
+  protected function setUp() {
+    parent::setUp();
+    $node_storage = $this->container->get('entity.manager')->getStorage('node');
+    $this->fieldName = strtolower($this->randomMachineName());
+
+    $type_name = 'article';
+    $this->createFileField($this->fieldName, 'node', $type_name);
+
+    // Set the teaser display to show this field.
+    entity_get_display('node', 'article', 'teaser')
+      ->setComponent($this->fieldName, array('type' => 'file_default'))
+      ->save();
+
+    // Set the RDF mapping for the new field.
+    $mapping = rdf_get_mapping('node', 'article');
+    $mapping->setFieldMapping($this->fieldName, array('properties' => array('rdfs:seeAlso'), 'mapping_type' => 'rel'))->save();
+
+    $test_file = $this->getTestFile('text');
+
+    // Create a new node with the uploaded file.
+    $nid = $this->uploadNodeFile($test_file, $this->fieldName, $type_name);
+
+    $node_storage->resetCache(array($nid));
+    $this->node = $node_storage->load($nid);
+    $this->file = File::load($this->node->{$this->fieldName}->target_id);
+  }
+
+  /**
+   * Tests if file fields in teasers have correct resources.
+   *
+   * Ensure that file fields have the correct resource as the object in RDFa
+   * when displayed as a teaser.
+   */
+  function testNodeTeaser() {
+    // Render the teaser.
+    $node_render_array = entity_view_multiple(array($this->node), 'teaser');
+    $html = \Drupal::service('renderer')->renderRoot($node_render_array);
+
+    // Parses front page where the node is displayed in its teaser form.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+    $parser->parse($graph, $html, 'rdfa', $base_uri);
+
+    $node_uri = $this->node->url('canonical', ['absolute' => TRUE]);
+    $file_uri = file_create_url($this->file->getFileUri());
+
+    // Node relation to attached file.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $file_uri,
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://www.w3.org/2000/01/rdf-schema#seeAlso', $expected_value), 'Node to file relation found in RDF output (rdfs:seeAlso).');
+    $this->drupalGet('node');
+  }
+
+}

web/core/modules/rdf/src/Tests/GetNamespacesTest.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Confirm that the serialization of RDF namespaces in present in the HTML
+ * markup.
+ *
+ * @group rdf
+ */
+class GetNamespacesTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'rdf_test_namespaces');
+
+  /**
+   * Tests RDF namespaces.
+   */
+  function testGetRdfNamespaces() {
+    // Fetches the front page and extracts RDFa 1.1 prefixes.
+    $this->drupalGet('');
+
+    $element = $this->xpath('//html[contains(@prefix, :prefix_binding)]', array(
+      ':prefix_binding' => 'rdfs: http://www.w3.org/2000/01/rdf-schema#',
+    ));
+    $this->assertTrue(!empty($element), 'A prefix declared once is displayed.');
+
+    $element = $this->xpath('//html[contains(@prefix, :prefix_binding)]', array(
+      ':prefix_binding' => 'foaf: http://xmlns.com/foaf/0.1/',
+    ));
+    $this->assertTrue(!empty($element), 'The same prefix declared in several implementations of hook_rdf_namespaces() is valid as long as all the namespaces are the same.');
+
+    $element = $this->xpath('//html[contains(@prefix, :prefix_binding)]', array(
+      ':prefix_binding' => 'foaf1: http://xmlns.com/foaf/0.1/',
+    ));
+    $this->assertTrue(!empty($element), 'Two prefixes can be assigned the same namespace.');
+
+    $element = $this->xpath('//html[contains(@prefix, :prefix_binding)]', array(
+      ':prefix_binding' => 'dc: http://purl.org/dc/terms/',
+    ));
+    $this->assertTrue(!empty($element), 'When a prefix has conflicting namespaces, the first declared one is used.');
+  }
+
+}

web/core/modules/rdf/src/Tests/GetRdfNamespacesTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests hook_rdf_namespaces().
+ *
+ * @group rdf
+ */
+class GetRdfNamespacesTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'rdf_test_namespaces');
+
+  /**
+   * Tests getting RDF namespaces.
+   */
+  function testGetRdfNamespaces() {
+    // Get all RDF namespaces.
+    $ns = rdf_get_namespaces();
+
+    $this->assertEqual($ns['rdfs'], 'http://www.w3.org/2000/01/rdf-schema#', 'A prefix declared once is included.');
+    $this->assertEqual($ns['foaf'], 'http://xmlns.com/foaf/0.1/', 'The same prefix declared in several implementations of hook_rdf_namespaces() is valid as long as all the namespaces are the same.');
+    $this->assertEqual($ns['foaf1'], 'http://xmlns.com/foaf/0.1/', 'Two prefixes can be assigned the same namespace.');
+
+    // Enable rdf_conflicting_namespaces to ensure that an exception is thrown
+    // when RDF namespaces are conflicting.
+    \Drupal::service('module_installer')->install(array('rdf_conflicting_namespaces'), TRUE);
+    try {
+      $ns = rdf_get_namespaces();
+      $this->fail('Expected exception not thrown for conflicting namespace declaration.');
+    }
+    catch (\Exception $e) {
+      $this->pass('Expected exception thrown: ' . $e->getMessage());
+    }
+  }
+
+}

web/core/modules/rdf/src/Tests/ImageFieldAttributesTest.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\image\Entity\ImageStyle;
+use Drupal\image\Tests\ImageFieldTestBase;
+use Drupal\node\Entity\Node;
+use Drupal\file\Entity\File;
+
+/**
+ * Tests the RDFa markup of imagefields.
+ *
+ * @group rdf
+ */
+class ImageFieldAttributesTest extends ImageFieldTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'image');
+
+  /**
+   * The name of the image field used in the test.
+   *
+   * @var string
+   */
+  protected $fieldName;
+
+  /**
+   * The file object used in the test.
+   *
+   * @var \Drupal\file\FileInterface
+   */
+  protected $file;
+
+  /**
+   * The node object used in the test.
+   *
+   * @var \Drupal\node\NodeInterface
+   */
+  protected $node;
+
+  protected function setUp() {
+    parent::setUp();
+
+    $this->fieldName = 'field_image';
+
+    // Create the image field.
+    $this->createImageField($this->fieldName, 'article');
+
+    // Set the RDF mapping for the new field.
+    rdf_get_mapping('node', 'article')
+      ->setFieldMapping($this->fieldName, array(
+        'properties' => array('og:image'),
+        'mapping_type' => 'rel',
+      ))
+      ->setBundleMapping(array('types' => array()))
+      ->save();
+
+    // Get the test image that simpletest provides.
+    $image = current($this->drupalGetTestFiles('image'));
+
+    // Save a node with the image.
+    $nid = $this->uploadNodeImage($image, $this->fieldName, 'article', $this->randomMachineName());
+    $this->node = Node::load($nid);
+    $this->file = File::load($this->node->{$this->fieldName}->target_id);
+  }
+
+  /**
+   * Tests that image fields in teasers have correct resources.
+   */
+  function testNodeTeaser() {
+    // Set the display options for the teaser.
+    $display_options = array(
+      'type' => 'image',
+      'settings' => array('image_style' => 'medium', 'image_link' => 'content'),
+    );
+    $display = entity_get_display('node', 'article', 'teaser');
+    $display->setComponent($this->fieldName, $display_options)
+      ->save();
+
+    // Render the teaser.
+    $node_render_array = node_view($this->node, 'teaser');
+    $html = \Drupal::service('renderer')->renderRoot($node_render_array);
+
+    // Parse the teaser.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+    $parser->parse($graph, $html, 'rdfa', $base_uri);
+
+    // Construct the node and image URIs for testing.
+    $node_uri = $this->node->url('canonical', ['absolute' => TRUE]);
+    $image_uri = ImageStyle::load('medium')->buildUrl($this->file->getFileUri());
+
+    // Test relations from node to image.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $image_uri,
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://ogp.me/ns#image', $expected_value), 'Node to file relation found in RDF output (og:image).');
+
+    // Test image type.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://xmlns.com/foaf/0.1/Image',
+    );
+    $this->assertTrue($graph->hasProperty($image_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Image type found in RDF output (foaf:Image).');
+  }
+
+}

web/core/modules/rdf/src/Tests/NodeAttributesTest.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\node\Tests\NodeTestBase;
+
+/**
+ * Tests the RDFa markup of Nodes.
+ *
+ * @group rdf
+ */
+class NodeAttributesTest extends NodeTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf');
+
+  protected function setUp() {
+    parent::setUp();
+
+    rdf_get_mapping('node', 'article')
+      ->setBundleMapping(array(
+        'types' => array('sioc:Item', 'foaf:Document'),
+      ))
+      ->setFieldMapping('title', array(
+        'properties' => array('dc:title'),
+      ))
+      ->setFieldMapping('created', array(
+        'properties' => array('dc:date', 'dc:created'),
+        'datatype' => 'xsd:dateTime',
+        'datatype_callback' => array('callable' => 'Drupal\rdf\CommonDataConverter::dateIso8601Value'),
+      ))
+      ->save();
+  }
+
+  /**
+   * Creates a node of type article and tests its RDFa markup.
+   */
+  function testNodeAttributes() {
+    // Create node with single quotation mark title to ensure it does not get
+    // escaped more than once.
+    $node = $this->drupalCreateNode(array(
+      'type' => 'article',
+      'title' => $this->randomMachineName(8) . "'",
+    ));
+
+    $node_uri = $node->url('canonical', ['absolute' => TRUE]);
+    $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+
+    // Parses front page where the node is displayed in its teaser form.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet('node/' . $node->id()), 'rdfa', $base_uri);
+
+    // Inspects RDF graph output.
+    // Node type.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://rdfs.org/sioc/ns#Item',
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Node type found in RDF output (sioc:Item).');
+    // Node type.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://xmlns.com/foaf/0.1/Document',
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Node type found in RDF output (foaf:Document).');
+    // Node title.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $node->getTitle(),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://purl.org/dc/terms/title', $expected_value), 'Node title found in RDF output (dc:title).');
+    // Node date (date format must be UTC).
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => \Drupal::service('date.formatter')->format($node->getCreatedTime(), 'custom', 'c', 'UTC'),
+      'datatype' => 'http://www.w3.org/2001/XMLSchema#dateTime',
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://purl.org/dc/terms/date', $expected_value), 'Node date found in RDF output (dc:date).');
+    // Node date (date format must be UTC).
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => \Drupal::service('date.formatter')->format($node->getCreatedTime(), 'custom', 'c', 'UTC'),
+      'datatype' => 'http://www.w3.org/2001/XMLSchema#dateTime',
+    );
+    $this->assertTrue($graph->hasProperty($node_uri, 'http://purl.org/dc/terms/created', $expected_value), 'Node date found in RDF output (dc:created).');
+  }
+
+}

web/core/modules/rdf/src/Tests/StandardProfileTest.php

@@ -0,0 +1,537 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\Core\Url;
+use Drupal\file\Entity\File;
+use Drupal\image\Entity\ImageStyle;
+use Drupal\node\Entity\NodeType;
+use Drupal\node\NodeInterface;
+use Drupal\simpletest\WebTestBase;
+use Drupal\comment\Entity\Comment;
+use Drupal\taxonomy\Entity\Term;
+
+/**
+ * Tests the RDF mappings and RDFa markup of the standard profile.
+ *
+ * @group rdf
+ */
+class StandardProfileTest extends WebTestBase {
+
+  /**
+   * The profile used during tests.
+   *
+   * This purposefully uses the standard profile.
+   *
+   * @var string
+   */
+  public $profile = 'standard';
+
+  /**
+   * @var string
+   */
+  protected $baseUri;
+
+  /**
+   * @var \Drupal\user\UserInterface
+   */
+  protected $adminUser;
+
+  /**
+   * @var \Drupal\user\UserInterface
+   */
+  protected $webUser;
+
+  /**
+   * @var \Drupal\taxonomy\TermInterface
+   */
+  protected $term;
+
+  /**
+   * @var \Drupal\file\FileInterface
+   */
+  protected $image;
+
+  /**
+   * @var \Drupal\node\NodeInterface
+   */
+  protected $article;
+
+  /**
+   * @var \Drupal\comment\CommentInterface
+   */
+  protected $articleComment;
+
+  /**
+   * @var \Drupal\node\NodeInterface
+   */
+  protected $page;
+
+  /**
+   * @var string
+   */
+  protected $imageUri;
+
+  /**
+   * @var string
+   */
+  protected $termUri;
+
+  /**
+   * @var string
+   */
+  protected $articleUri;
+
+  /**
+   * @var string
+   */
+  protected $pageUri;
+
+  /**
+   * @var string
+   */
+  protected $authorUri;
+
+  /**
+   * @var string
+   */
+  protected $articleCommentUri;
+
+  /**
+   * @var string
+   */
+  protected $commenterUri;
+
+  protected function setUp() {
+    parent::setUp();
+
+    // Use Classy theme for testing markup output.
+    \Drupal::service('theme_handler')->install(['classy']);
+    \Drupal::service('theme_handler')->setDefault('classy');
+
+    $this->baseUri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+
+    // Create two test users.
+    $this->adminUser = $this->drupalCreateUser(array(
+      'administer content types',
+      'administer comments',
+      'access comments',
+      'access content',
+    ));
+    $this->webUser = $this->drupalCreateUser(array(
+      'access comments',
+      'post comments',
+      'skip comment approval',
+      'access content',
+    ));
+
+    $this->drupalLogin($this->adminUser);
+
+    // Create term.
+    $this->term = Term::create([
+      'name' => $this->randomMachineName(),
+      'description' => $this->randomMachineName(),
+      'vid' => 'tags',
+    ]);
+    $this->term->save();
+
+    // Create image.
+    file_unmanaged_copy(\Drupal::root() . '/core/misc/druplicon.png', 'public://example.jpg');
+    $this->image = File::create(['uri' => 'public://example.jpg']);
+    $this->image->save();
+
+    // Create article.
+    $article_settings = array(
+      'type' => 'article',
+      'promote' => NODE_PROMOTED,
+      'field_image' => array(
+        array(
+          'target_id' => $this->image->id(),
+        ),
+      ),
+      'field_tags' => array(
+        array(
+          'target_id' => $this->term->id(),
+        ),
+      ),
+    );
+    $this->article = $this->drupalCreateNode($article_settings);
+    // Create second article to test teaser list.
+    $this->drupalCreateNode(array('type' => 'article', 'promote' => NODE_PROMOTED,));
+
+    // Create article comment.
+    $this->articleComment = $this->saveComment($this->article->id(), $this->webUser->id(), NULL, 0);
+
+    // Create page.
+    $this->page = $this->drupalCreateNode(array('type' => 'page'));
+
+    // Set URIs.
+    // Image.
+    $image_file = $this->article->get('field_image')->entity;
+    $this->imageUri = ImageStyle::load('large')->buildUrl($image_file->getFileUri());
+    // Term.
+    $this->termUri = $this->term->url('canonical', array('absolute' => TRUE));
+    // Article.
+    $this->articleUri = $this->article->url('canonical', array('absolute' => TRUE));
+    // Page.
+    $this->pageUri = $this->page->url('canonical', array('absolute' => TRUE));
+    // Author.
+    $this->authorUri = $this->adminUser->url('canonical', array('absolute' => TRUE));
+    // Comment.
+    $this->articleCommentUri = $this->articleComment->url('canonical', array('absolute' => TRUE));
+    // Commenter.
+    $this->commenterUri = $this->webUser->url('canonical', array('absolute' => TRUE));
+
+    $this->drupalLogout();
+  }
+
+  /**
+   * Tests that data is exposed correctly when using standard profile.
+   *
+   * Because tests using standard profile take a very long time to run, and
+   * because there is no manipulation of config or data within the test, simply
+   * run all the tests from within this function.
+   */
+  public function testRdfaOutput() {
+    $this->doFrontPageRdfaTests();
+    $this->doArticleRdfaTests();
+    $this->doPageRdfaTests();
+    $this->doUserRdfaTests();
+    $this->doTermRdfaTests();
+  }
+
+  /**
+   * Tests that data is exposed in the front page teasers.
+   */
+  protected function doFrontPageRdfaTests() {
+    // Feed the HTML into the parser.
+    $graph = $this->getRdfGraph(Url::fromRoute('<front>'));
+
+    // Ensure that both articles are listed.
+    $this->assertEqual(2, count($graph->allOfType('http://schema.org/Article')), 'Two articles found on front page.');
+
+    // Test interaction count.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => 'UserComments:1',
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($this->articleUri, 'http://schema.org/interactionCount', $expected_value), "Teaser comment count was found (schema:interactionCount).");
+
+    // Test the properties that are common between pages and articles and are
+    // displayed in full and teaser mode.
+    $this->assertRdfaCommonNodeProperties($graph, $this->article, "Teaser");
+    // Test properties that are displayed in both teaser and full mode.
+    $this->assertRdfaArticleProperties($graph, "Teaser");
+
+    // @todo Once the image points to the original instead of the processed
+    //   image, move this to testArticleProperties().
+    $image_file = $this->article->get('field_image')->entity;
+    $image_uri = ImageStyle::load('medium')->buildUrl($image_file->getFileUri());
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $image_uri,
+    );
+    $this->assertTrue($graph->hasProperty($this->articleUri, 'http://schema.org/image', $expected_value), "Teaser image was found (schema:image).");
+  }
+
+  /**
+   * Tests that article data is exposed using RDFa.
+   *
+   * Two fields are not tested for output here. Changed date is not displayed
+   * on the page, so there is no test for output in node view. Comment count is
+   * displayed in teaser view, so it is tested in the front article tests.
+   */
+  protected function doArticleRdfaTests() {
+    // Feed the HTML into the parser.
+    $graph = $this->getRdfGraph($this->article->urlInfo());
+
+    // Type.
+    $this->assertEqual($graph->type($this->articleUri), 'schema:Article', 'Article type was found (schema:Article).');
+
+    // Test the properties that are common between pages and articles.
+    $this->assertRdfaCommonNodeProperties($graph, $this->article, "Article");
+    // Test properties that are displayed in both teaser and full mode.
+    $this->assertRdfaArticleProperties($graph, "Article");
+    // Test the comment properties displayed on articles.
+    $this->assertRdfaNodeCommentProperties($graph);
+
+    // @todo Once the image points to the original instead of the processed
+    //   image, move this to testArticleProperties().
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->imageUri,
+    );
+    $this->assertTrue($graph->hasProperty($this->articleUri, 'http://schema.org/image', $expected_value), "Article image was found (schema:image).");
+  }
+
+  /**
+   * Tests that page data is exposed using RDFa.
+   *
+   * Two fields are not tested for output here. Changed date is not displayed
+   * on the page, so there is no test for output in node view. Comment count is
+   * displayed in teaser view, so it is tested in the front page tests.
+   */
+  protected function doPageRdfaTests() {
+    // The standard profile hides the created date on pages. Revert display to
+    // true for testing.
+    // @todo Clean-up standard profile defaults.
+    $node_type = NodeType::load('page');
+    $node_type->setDisplaySubmitted(TRUE);
+    $node_type->save();
+
+    // Feed the HTML into the parser.
+    $graph = $this->getRdfGraph($this->page->urlInfo());
+
+    // Type.
+    $this->assertEqual($graph->type($this->pageUri), 'schema:WebPage', 'Page type was found (schema:WebPage).');
+
+    // Test the properties that are common between pages and articles.
+    $this->assertRdfaCommonNodeProperties($graph, $this->page, "Page");
+  }
+
+  /**
+   * Tests that user data is exposed on user page.
+   */
+  protected function doUserRdfaTests() {
+    $this->drupalLogin($this->rootUser);
+
+    // Feed the HTML into the parser.
+    $graph = $this->getRdfGraph($this->adminUser->urlInfo());
+
+    // User type.
+    $this->assertEqual($graph->type($this->authorUri), 'schema:Person', "User type was found (schema:Person) on user page.");
+
+    // User name.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $this->adminUser->label(),
+    );
+    $this->assertTrue($graph->hasProperty($this->authorUri, 'http://schema.org/name', $expected_value), "User name was found (schema:name) on user page.");
+
+    $this->drupalLogout();
+  }
+
+  /**
+   * Tests that term data is exposed on term page.
+   */
+  protected function doTermRdfaTests() {
+    // Feed the HTML into the parser.
+    $graph = $this->getRdfGraph($this->term->urlInfo());
+
+    // Term type.
+    $this->assertEqual($graph->type($this->termUri), 'schema:Thing', "Term type was found (schema:Thing) on term page.");
+
+    // Term name.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $this->term->getName(),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($this->termUri, 'http://schema.org/name', $expected_value), "Term name was found (schema:name) on term page.");
+
+    // @todo Add test for term description once it is a field:
+    //   https://www.drupal.org/node/569434.
+  }
+
+  /**
+   * Tests output for properties held in common between articles and pages.
+   *
+   * @param \EasyRdf_Graph $graph
+   *   The EasyRDF graph object.
+   * @param \Drupal\node\NodeInterface $node
+   *   The node being displayed.
+   * @param string $message_prefix
+   *   The word to use in the test assertion message.
+   */
+  protected function assertRdfaCommonNodeProperties($graph, NodeInterface $node, $message_prefix) {
+    $uri = $node->url('canonical', array('absolute' => TRUE));
+
+    // Title.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $node->get('title')->value,
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($uri, 'http://schema.org/name', $expected_value), "$message_prefix title was found (schema:name).");
+
+    // Created date.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => format_date($node->get('created')->value, 'custom', 'c', 'UTC'),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($uri, 'http://schema.org/dateCreated', $expected_value), "$message_prefix created date was found (schema:dateCreated) in teaser.");
+
+    // Body.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $node->get('body')->value,
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($uri, 'http://schema.org/text', $expected_value), "$message_prefix body was found (schema:text) in teaser.");
+
+    // Author.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->authorUri,
+    );
+    $this->assertTrue($graph->hasProperty($uri, 'http://schema.org/author', $expected_value), "$message_prefix author was found (schema:author) in teaser.");
+
+    // Author type.
+    $this->assertEqual($graph->type($this->authorUri), 'schema:Person', "$message_prefix author type was found (schema:Person).");
+
+    // Author name.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $this->adminUser->label(),
+    );
+    $this->assertTrue($graph->hasProperty($this->authorUri, 'http://schema.org/name', $expected_value), "$message_prefix author name was found (schema:name).");
+  }
+
+  /**
+   * Tests output for article properties displayed in both view modes.
+   *
+   * @param \EasyRdf_Graph $graph
+   *   The EasyRDF graph object.
+   * @param string $message_prefix
+   *   The word to use in the test assertion message.
+   */
+  protected function assertRdfaArticleProperties($graph, $message_prefix) {
+    // Tags.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->termUri,
+    );
+    $this->assertTrue($graph->hasProperty($this->articleUri, 'http://schema.org/about', $expected_value), "$message_prefix tag was found (schema:about).");
+
+    // Tag type.
+    // @todo Enable with https://www.drupal.org/node/2072791.
+    //$this->assertEqual($graph->type($this->termUri), 'schema:Thing', 'Tag type was found (schema:Thing).');
+
+    // Tag name.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $this->term->getName(),
+      'lang' => 'en',
+    );
+    // @todo Enable with https://www.drupal.org/node/2072791.
+    //$this->assertTrue($graph->hasProperty($this->termUri, 'http://schema.org/name', $expected_value), "$message_prefix name was found (schema:name).");
+  }
+
+  /**
+   * Tests output for comment properties on nodes in full page view mode.
+   *
+   * @param \EasyRdf_Graph $graph
+   *   The EasyRDF graph object.
+   */
+  protected function assertRdfaNodeCommentProperties($graph) {
+    // Relationship between node and comment.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->articleCommentUri,
+    );
+    $this->assertTrue($graph->hasProperty($this->articleUri, 'http://schema.org/comment', $expected_value), 'Relationship between node and comment found (schema:comment).');
+
+    // Comment type.
+    $this->assertEqual($graph->type($this->articleCommentUri), 'schema:Comment', 'Comment type was found (schema:Comment).');
+
+    // Comment title.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $this->articleComment->get('subject')->value,
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($this->articleCommentUri, 'http://schema.org/name', $expected_value), 'Article comment title was found (schema:name).');
+
+    // Comment created date.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => format_date($this->articleComment->get('created')->value, 'custom', 'c', 'UTC'),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($this->articleCommentUri, 'http://schema.org/dateCreated', $expected_value), 'Article comment created date was found (schema:dateCreated).');
+
+    // Comment body.
+    $text = $this->articleComment->get('comment_body')->value;
+    $expected_value = array(
+      'type' => 'literal',
+      // There is an extra carriage return in the when parsing comments as
+      // output by Bartik, so it must be added to the expected value.
+      'value' => "$text
+",
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($this->articleCommentUri, 'http://schema.org/text', $expected_value), 'Article comment body was found (schema:text).');
+
+    // Comment uid.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => $this->commenterUri,
+    );
+    $this->assertTrue($graph->hasProperty($this->articleCommentUri, 'http://schema.org/author', $expected_value), 'Article comment author was found (schema:author).');
+
+    // Comment author type.
+    $this->assertEqual($graph->type($this->commenterUri), 'schema:Person', 'Comment author type was found (schema:Person).');
+
+    // Comment author name.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $this->webUser->getUsername(),
+    );
+    $this->assertTrue($graph->hasProperty($this->commenterUri, 'http://schema.org/name', $expected_value), 'Comment author name was found (schema:name).');
+  }
+
+  /**
+   * Creates a comment entity.
+   *
+   * @param int $nid
+   *   Node id which will hold the comment.
+   * @param int $uid
+   *   User id of the author of the comment. Can be NULL if $contact provided.
+   * @param mixed $contact
+   *   Set to NULL for no contact info, TRUE to ignore success checking, and
+   *   array of values to set contact info.
+   * @param int $pid
+   *   Comment id of the parent comment in a thread.
+   *
+   * @return \Drupal\comment\Entity\Comment
+   *   The saved comment.
+   */
+  protected function saveComment($nid, $uid, $contact = NULL, $pid = 0) {
+    $values = array(
+      'entity_id' => $nid,
+      'entity_type' => 'node',
+      'field_name' => 'comment',
+      'uid' => $uid,
+      'pid' => $pid,
+      'subject' => $this->randomMachineName(),
+      'comment_body' => $this->randomMachineName(),
+      'status' => 1,
+    );
+    if ($contact) {
+      $values += $contact;
+    }
+
+    $comment = Comment::create($values);
+    $comment->save();
+    return $comment;
+  }
+
+  /**
+   * Get the EasyRdf_Graph object for a page.
+   *
+   * @param \Drupal\Core\Url $url
+   *   The URL object for the page.
+   *
+   * @return \EasyRdf_Graph
+   *   The RDF graph object.
+   */
+  protected function getRdfGraph(Url $url) {
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $parser->parse($graph, $this->drupalGet($url), 'rdfa', $this->baseUri);
+    return $graph;
+  }
+
+}

web/core/modules/rdf/src/Tests/TaxonomyAttributesTest.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\taxonomy\Tests\TaxonomyTestBase;
+
+/**
+ * Tests the RDFa markup of Taxonomy terms.
+ *
+ * @group rdf
+ */
+class TaxonomyAttributesTest extends TaxonomyTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'views');
+
+  /**
+   * Vocabulary created for testing purposes.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
+  protected function setUp() {
+    parent::setUp();
+
+    $this->vocabulary = $this->createVocabulary();
+
+    // RDF mapping - term bundle.
+    rdf_get_mapping('taxonomy_term', $this->vocabulary->id())
+      ->setBundleMapping(array('types' => array('skos:Concept')))
+      ->setFieldMapping('name', array(
+        'properties' => array('rdfs:label', 'skos:prefLabel'),
+      ))
+      ->save();
+  }
+
+  /**
+   * Creates a random term and ensures the RDF output is correct.
+   */
+  function testTaxonomyTermRdfaAttributes() {
+    $term = $this->createTerm($this->vocabulary);
+    $term_uri = $term->url('canonical', ['absolute' => TRUE]);
+
+    // Parses the term's page and checks that the RDF output is correct.
+    $parser = new \EasyRdf_Parser_Rdfa();
+    $graph = new \EasyRdf_Graph();
+    $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+    $parser->parse($graph, $this->drupalGet('taxonomy/term/' . $term->id()), 'rdfa', $base_uri);
+
+    // Inspects RDF graph output.
+    // Term type.
+    $expected_value = array(
+      'type' => 'uri',
+      'value' => 'http://www.w3.org/2004/02/skos/core#Concept',
+    );
+    $this->assertTrue($graph->hasProperty($term_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'Term type found in RDF output (skos:Concept).');
+    // Term label.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $term->getName(),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($term_uri, 'http://www.w3.org/2000/01/rdf-schema#label', $expected_value), 'Term label found in RDF output (rdfs:label).');
+    // Term label.
+    $expected_value = array(
+      'type' => 'literal',
+      'value' => $term->getName(),
+      'lang' => 'en',
+    );
+    $this->assertTrue($graph->hasProperty($term_uri, 'http://www.w3.org/2004/02/skos/core#prefLabel', $expected_value), 'Term label found in RDF output (skos:prefLabel).');
+
+    // @todo Add test for term description once it is a field:
+    //   https://www.drupal.org/node/569434.
+  }
+
+}

web/core/modules/rdf/src/Tests/UserAttributesTest.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Drupal\rdf\Tests;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests the RDFa markup of Users.
+ *
+ * @group rdf
+ */
+class UserAttributesTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('rdf', 'node');
+
+  protected function setUp() {
+    parent::setUp();
+    rdf_get_mapping('user', 'user')
+      ->setBundleMapping(array(
+        'types' => array('sioc:UserAccount'),
+      ))
+      ->setFieldMapping('name', array(
+        'properties' => array('foaf:name'),
+      ))
+      ->save();
+  }
+
+  /**
+   * Tests if default mapping for user is being used.
+   *
+   * Creates a random user and ensures the default mapping for the user is
+   * being used.
+   */
+  function testUserAttributesInMarkup() {
+    // Creates users that should and should not be truncated
+    // by template_preprocess_username (20 characters)
+    // one of these users tests right on the cusp (20).
+    $user1 = $this->drupalCreateUser(array('access user profiles'));
+
+    $authors = array(
+      $this->drupalCreateUser(array(), $this->randomMachineName(30)),
+      $this->drupalCreateUser(array(), $this->randomMachineName(20)),
+      $this->drupalCreateUser(array(), $this->randomMachineName(5))
+    );
+
+    $this->drupalLogin($user1);
+
+    $this->drupalCreateContentType(array('type' => 'article'));
+
+    /** @var \Drupal\user\UserInterface[] $authors */
+    foreach ($authors as $author) {
+      $account_uri = $author->url('canonical', ['absolute' => TRUE]);
+
+      // Parses the user profile page where the default bundle mapping for user
+      // should be used.
+      $parser = new \EasyRdf_Parser_Rdfa();
+      $graph = new \EasyRdf_Graph();
+      $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+      $parser->parse($graph, $this->drupalGet('user/' . $author->id()), 'rdfa', $base_uri);
+
+      // Inspects RDF graph output.
+      // User type.
+      $expected_value = array(
+        'type' => 'uri',
+        'value' => 'http://rdfs.org/sioc/ns#UserAccount',
+      );
+      $this->assertTrue($graph->hasProperty($account_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'User type found in RDF output (sioc:UserAccount).');
+      // User name.
+      $expected_value = array(
+        'type' => 'literal',
+        'value' => $author->getUsername(),
+      );
+      $this->assertTrue($graph->hasProperty($account_uri, 'http://xmlns.com/foaf/0.1/name', $expected_value), 'User name found in RDF output (foaf:name).');
+
+      // User creates a node.
+      $this->drupalLogin($author);
+      $node = $this->drupalCreateNode(array('type' => 'article', 'promote' => 1));
+      $this->drupalLogin($user1);
+
+      // Parses the node created by the user.
+      $parser = new \EasyRdf_Parser_Rdfa();
+      $graph = new \EasyRdf_Graph();
+      $base_uri = \Drupal::url('<front>', [], ['absolute' => TRUE]);
+      $parser->parse($graph, $this->drupalGet('node/' . $node->id()), 'rdfa', $base_uri);
+
+      // Ensures the default bundle mapping for user is used on the Authored By
+      // information on the node.
+      $expected_value = array(
+        'type' => 'uri',
+        'value' => 'http://rdfs.org/sioc/ns#UserAccount',
+      );
+      $this->assertTrue($graph->hasProperty($account_uri, 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $expected_value), 'User type found in RDF output (sioc:UserAccount).');
+      // User name.
+      $expected_value = array(
+        'type' => 'literal',
+        'value' => $author->getUsername(),
+      );
+      $this->assertTrue($graph->hasProperty($account_uri, 'http://xmlns.com/foaf/0.1/name', $expected_value), 'User name found in RDF output (foaf:name).');
+
+    }
+  }
+
+}