diff --git a/core/modules/hal/src/Normalizer/ContentEntityNormalizer.php b/core/modules/hal/src/Normalizer/ContentEntityNormalizer.php
index 61ea214..110378f 100644
--- a/core/modules/hal/src/Normalizer/ContentEntityNormalizer.php
+++ b/core/modules/hal/src/Normalizer/ContentEntityNormalizer.php
@@ -171,11 +171,8 @@ public function denormalize($data, $class, $format = NULL, array $context = arra
       }
     }
 
-    // Special handling for PATCH: pass the names of the fields whose values
-    // should be merged.
-    if (isset($context['request_method']) && $context['request_method'] == 'patch') {
-      $entity->_restPatchFields = array_keys($data);
-    }
+    // Pass the names of the fields whose values can be merged.
+    $entity->_restSubmittedFields = array_keys($data);
 
     // Iterate through remaining items in data array. These should all
     // correspond to fields.
diff --git a/core/modules/hal/src/Tests/DenormalizeTest.php b/core/modules/hal/src/Tests/DenormalizeTest.php
index 6931d1c..9faad6e 100644
--- a/core/modules/hal/src/Tests/DenormalizeTest.php
+++ b/core/modules/hal/src/Tests/DenormalizeTest.php
@@ -196,6 +196,6 @@ public function testPatchDenormailzation() {
     // Check that the one field got populated as expected.
     $this->assertEqual($data['field_test_text'], $denormalized->get('field_test_text')->getValue());
     // Check the custom property that contains the list of fields to merge.
-    $this->assertEqual($denormalized->_restPatchFields, ['field_test_text']);
+    $this->assertEqual($denormalized->_restSubmittedFields, ['field_test_text']);
   }
 }
diff --git a/core/modules/rest/src/Plugin/rest/resource/EntityResource.php b/core/modules/rest/src/Plugin/rest/resource/EntityResource.php
index 0f2a785..1227f71 100644
--- a/core/modules/rest/src/Plugin/rest/resource/EntityResource.php
+++ b/core/modules/rest/src/Plugin/rest/resource/EntityResource.php
@@ -87,9 +87,13 @@ public function post(EntityInterface $entity = NULL) {
     if (!$entity->isNew()) {
       throw new BadRequestHttpException('Only new entities can be created');
     }
-    foreach ($entity as $field_name => $field) {
-      if (!$field->access('create')) {
-        throw new AccessDeniedHttpException(String::format('Access denied on creating field ', array('@field' => $field_name)));
+
+    // Only want to check 'edit' permissions for fields that were actually
+    // submitted by the user.Field access makes no difference between 'create'
+    // and 'update', so the 'edit' operation is used here.
+    foreach ($entity->_restSubmittedFields as $key => $field_name) {
+      if (!$entity->get($field_name)->access('edit')) {
+        throw new AccessDeniedHttpException(String::format('Access denied on creating field @field', array('@field' => $field_name)));
       }
     }
 
@@ -135,7 +139,7 @@ public function patch(EntityInterface $original_entity, EntityInterface $entity
 
     // Overwrite the received properties.
     $langcode_key = $entity->getEntityType()->getKey('langcode');
-    foreach ($entity->_restPatchFields as $field_name) {
+    foreach ($entity->_restSubmittedFields as $field_name) {
       $field = $entity->get($field_name);
       // It is not possible to set the language to NULL as it is automatically
       // re-initialized. As it must not be empty, skip it if it is.
diff --git a/core/modules/rest/src/Tests/CreateTest.php b/core/modules/rest/src/Tests/CreateTest.php
index e547c2c..ae61ee7 100644
--- a/core/modules/rest/src/Tests/CreateTest.php
+++ b/core/modules/rest/src/Tests/CreateTest.php
@@ -23,104 +23,290 @@ class CreateTest extends RESTTestBase {
    */
   public static $modules = array('hal', 'rest', 'entity_test');
 
+  protected $serializer;
+
   /**
-   * Tests several valid and invalid create requests on all entity types.
+   * {@inheritdoc}
    */
-  public function testCreate() {
-    $serializer = $this->container->get('serializer');
-    $entity_types = array('entity_test', 'node');
-    foreach ($entity_types as $entity_type) {
-
-      $this->enableService('entity:' . $entity_type, 'POST');
-      // Create a user account that has the required permissions to create
-      // resources via the REST API.
-      $permissions = $this->entityPermissions($entity_type, 'create');
-      $permissions[] = 'restful post entity:' . $entity_type;
-      $account = $this->drupalCreateUser($permissions);
-      $this->drupalLogin($account);
+  protected function setUp() {
+    parent::setUp();
+    $this->serializer = $this->container->get('serializer');
+  }
+
+  /**
+   * Try to create a resource which is not REST API enabled.
+   */
+  public function testCreateResourceRestApiNotEnabled() {
+    $entity_type = 'entity_test';
+    $this->enableService('entity:' . $entity_type, 'POST');
+
+    $permissions = $this->entityPermissions($entity_type, 'create');
+    $permissions[] = 'restful post entity:' . $entity_type;
+
+    // Create non-admin user.
+    $account = $this->drupalCreateUser($permissions);
+    $entity_values = $this->entityValues($entity_type);
+    $entity = entity_create($entity_type, $entity_values);
 
+    $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
+
+    $this->enableService(FALSE);
+    $this->drupalLogin($account);
+    $this->httpRequest('entity/entity_test', 'POST', $serialized, $this->defaultMimeType);
+    $this->assertResponse(404);
+    $this->assertFalse(entity_load_multiple('entity_test', NULL, TRUE), 'No entity has been created in the database.');
+  }
+
+  /**
+   * Tests several valid and invalid create requests for 'entity_test' entity type.
+   */
+  public function testCreateEntityTest() {
+    $entity_type = 'entity_test';
+    $this->enableService('entity:' . $entity_type, 'POST');
+    // Create accounts (admin and non-admin).
+    $accounts = $this->createAccountPerEntity($entity_type);
+
+    foreach ($accounts as $key => $account) {
+      $this->drupalLogin($account);
       $entity_values = $this->entityValues($entity_type);
       $entity = entity_create($entity_type, $entity_values);
-      $serialized = $serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
+
+      $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
+
       // Create the entity over the REST API.
-      $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
-      $this->assertResponse(201);
-
-      // Get the new entity ID from the location header and try to read it from
-      // the database.
-      $location_url = $this->drupalGetHeader('location');
-      $url_parts = explode('/', $location_url);
-      $id = end($url_parts);
-      $loaded_entity = entity_load($entity_type, $id);
-      $this->assertNotIdentical(FALSE, $loaded_entity, 'The new ' . $entity_type . ' was found in the database.');
-      $this->assertEqual($entity->uuid(), $loaded_entity->uuid(), 'UUID of created entity is correct.');
-      // @todo Remove the user reference field for now until deserialization for
-      // entity references is implemented.
-      unset($entity_values['user_id']);
-      foreach ($entity_values as $property => $value) {
-        $actual_value = $loaded_entity->get($property)->value;
-        $send_value = $entity->get($property)->value;
-        $this->assertEqual($send_value, $actual_value, 'Created property ' . $property . ' expected: ' . $send_value . ', actual: ' . $actual_value);
-      }
+      $this->createEntityOverRestApi($entity_type, $serialized);
+      $this->readEntityIdFromHeaderAndDb($entity_type, $entity, $entity_values);
 
-      $loaded_entity->delete();
 
       // Try to create an entity with an access protected field.
       // @see entity_test_entity_field_access()
-      if ($entity_type == 'entity_test') {
-        $context = ['account' => $account];
-        $normalized = $serializer->normalize($entity, $this->defaultFormat, $context);
-        $normalized['field_test_text'][0]['value'] = 'no access value';
-        $this->httpRequest('entity/' . $entity_type, 'POST', $serializer->serialize($normalized, $this->defaultFormat, $context), $this->defaultMimeType);
-        $this->assertResponse(403);
-        $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
+      $context = ['account' => $account];
+      $normalized = $this->serializer->normalize($entity, $this->defaultFormat, $context);
+      $normalized['field_test_text'][0]['value'] = 'no access value';
+      $this->httpRequest('entity/' . $entity_type, 'POST', $this->serializer->serialize($normalized, $this->defaultFormat, $context), $this->defaultMimeType);
+      $this->assertResponse(403);
+      $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
+
+      // Try to create a field with a text format this user has no access to.
+      $entity->field_test_text->value = $entity_values['field_test_text'][0]['value'];
+      $entity->field_test_text->format = 'full_html';
+      $serialized = $this->serializer->serialize($entity, $this->defaultFormat, $context);
+      $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
+      $this->assertResponse(422);
+      $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
+
+      // Restore the valid test value.
+      $entity->field_test_text->format = 'plain_text';
+      $serialized = $this->serializer->serialize($entity, $this->defaultFormat, $context);
 
-        // Try to create a field with a text format this user has no access to.
-        $entity->field_test_text->value = $entity_values['field_test_text'][0]['value'];
-        $entity->field_test_text->format = 'full_html';
-        $serialized = $serializer->serialize($entity, $this->defaultFormat, $context);
+      $this->createEntityInvalidData($entity_type);
+
+      $this->createEntityNoData($entity_type);
+
+      $this->createEntityInvalidSerialized($entity, $entity_type);
+
+      $this->createEntityWithoutProperPermissions($entity_type, $serialized, $context);
+
+    }
+
+  }
+
+  /**
+   * Tests several valid and invalid create requests for 'node' entity type.
+   */
+  public function testCreateNode() {
+    $entity_type = 'node';
+    $this->enableService('entity:' . $entity_type, 'POST');
+    // Create accounts (admin and non-admin).
+    $accounts = $this->createAccountPerEntity($entity_type);
+
+    foreach ($accounts as $key => $account) {
+      $this->drupalLogin($account);
+      $entity_values = $this->entityValues($entity_type);
+      $entity = entity_create($entity_type, $entity_values);
+
+      // Verify that user cannot create content when trying to write to fields where it is not possible.
+      if (!$account->hasPermission('administer nodes')) {
+        $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
         $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
-        $this->assertResponse(422);
-        $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
+        $this->assertResponse(403);
+        // Remove fields where non-admin users cannot write.
+        $entity = $this->removeNodeFieldsForNonAdminUsers($entity);
+      }
+      else {
+        // Changed and revision_timestamp fields can never be added.
+        unset($entity->changed);
+        unset($entity->revision_timestamp);
+      }
+
+      $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
+
+      $this->createEntityOverRestApi($entity_type, $serialized);
+
+      $this->readEntityIdFromHeaderAndDb($entity_type, $entity, $entity_values);
+
+      $this->createEntityInvalidData($entity_type);
+
+      $this->createEntityNoData($entity_type);
 
-        // Restore the valid test value.
-        $entity->field_test_text->format = 'plain_text';
-        $serialized = $serializer->serialize($entity, $this->defaultFormat, $context);
+      $this->createEntityInvalidSerialized($entity, $entity_type);
+
+      $this->createEntityWithoutProperPermissions($entity_type, $serialized);
+
+    }
+
+  }
+
+  /**
+   * Tests several valid and invalid create requests for 'user' entity type.
+   */
+  public function testCreateUser() {
+    $entity_type = 'user';
+    $this->enableService('entity:' . $entity_type, 'POST');
+    // Create accounts (admin and non-admin).
+    $accounts = $this->createAccountPerEntity($entity_type);
+
+    foreach ($accounts as $key => $account) {
+      $this->drupalLogin($account);
+      $entity_values = $this->entityValues($entity_type);
+      $entity = entity_create($entity_type, $entity_values);
+
+      // Verify that user cannot create content when trying to write to fields where it is not possible.
+      if (!$account->hasPermission('administer users')) {
+        $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
+        $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
+        $this->assertResponse(403);
+        // Remove fields where non-admin users cannot write.
+        $entity = $this->removeUserFieldsForNonAdminUsers($entity);
+      }
+      else {
+        // Changed field can never be added.
+        unset($entity->changed);
       }
 
-      // Try to send invalid data that cannot be correctly deserialized.
-      $this->httpRequest('entity/' . $entity_type, 'POST', 'kaboom!', $this->defaultMimeType);
-      $this->assertResponse(400);
+      $serialized = $this->serializer->serialize($entity, $this->defaultFormat, ['account' => $account]);
 
-      // Try to send no data at all, which does not make sense on POST requests.
-      $this->httpRequest('entity/' . $entity_type, 'POST', NULL, $this->defaultMimeType);
-      $this->assertResponse(400);
+      $this->createEntityOverRestApi($entity_type, $serialized);
 
-      // Try to send invalid data to trigger the entity validation constraints.
-      // Send a UUID that is too long.
-      $entity->set('uuid', $this->randomMachineName(129));
-      $invalid_serialized = $serializer->serialize($entity, $this->defaultFormat, $context);
-      $response = $this->httpRequest('entity/' . $entity_type, 'POST', $invalid_serialized, $this->defaultMimeType);
-      $this->assertResponse(422);
-      $error = Json::decode($response);
-      $this->assertEqual($error['error'], "Unprocessable Entity: validation failed.\nuuid.0.value: <em class=\"placeholder\">UUID</em>: may not be longer than 128 characters.\n");
+      $this->readEntityIdFromHeaderAndDb($entity_type, $entity, $entity_values);
+
+      $this->createEntityInvalidData($entity_type);
+
+      $this->createEntityNoData($entity_type);
+
+      $this->createEntityInvalidSerialized($entity, $entity_type);
+
+      $this->createEntityWithoutProperPermissions($entity_type, $serialized);
 
-      // Try to create an entity without proper permissions.
-      $this->drupalLogout();
-      $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
-      $this->assertResponse(403);
-      $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
     }
 
-    // Try to create a resource which is not REST API enabled.
-    $this->enableService(FALSE);
-    $this->drupalLogin($account);
-    $this->httpRequest('entity/entity_test', 'POST', $serialized, $this->defaultMimeType);
-    $this->assertResponse(404);
-    $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
+  }
+
+  /**
+   * Creates user accounts(admin and non-admin) that have the required permissions to create resources via the REST API.
+   *
+   * @param $entity_type
+   * @return array
+   */
+  public function createAccountPerEntity($entity_type) {
+    $accounts = array();
+    $permissions = $this->entityPermissions($entity_type, 'create');
+    $permissions[] = 'restful post entity:' . $entity_type;
+    // Create non-admin user.
+    $accounts[] = $this->drupalCreateUser($permissions);
+    // Admin permissions.
+    $permissions[] = 'administer nodes';
+    $permissions[] = 'administer users';
+    // Create admin user.
+    $accounts[] = $this->drupalCreateUser($permissions);
+
+    return $accounts;
+  }
+
+  /**
+   * Create the entity over the REST API.
+   *
+   * @param $entity_type
+   * @param $serialized
+   */
+  public function createEntityOverRestApi($entity_type, $serialized) {
+    $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
+    $this->assertResponse(201);
+  }
+
+  /**
+   * Get the new entity ID from the location header and try to read it from the database.
+   *
+   * @param $entity_type
+   * @param $entity
+   * @param $entity_values
+   */
+  public function readEntityIdFromHeaderAndDb($entity_type, $entity, $entity_values) {
+    $location_url = $this->drupalGetHeader('location');
+    $url_parts = explode('/', $location_url);
+    $id = end($url_parts);
+    $loaded_entity = entity_load($entity_type, $id);
+    $this->assertNotIdentical(FALSE, $loaded_entity, 'The new ' . $entity_type . ' was found in the database.');
+    $this->assertEqual($entity->uuid(), $loaded_entity->uuid(), 'UUID of created entity is correct.');
+    // @todo Remove the user reference field for now until deserialization for
+    // entity references is implemented.
+    unset($entity_values['user_id']);
+    foreach ($entity_values as $property => $value) {
+      $actual_value = $loaded_entity->get($property)->value;
+      $send_value = $entity->get($property)->value;
+      $this->assertEqual($send_value, $actual_value, 'Created property ' . $property . ' expected: ' . $send_value . ', actual: ' . $actual_value);
+    }
+
+    $loaded_entity->delete();
+  }
+
+  /**
+   * Try to send invalid data that cannot be correctly deserialized.
+   *
+   * @param $entity_type
+   */
+  public function createEntityInvalidData($entity_type) {
+    $this->httpRequest('entity/' . $entity_type, 'POST', 'kaboom!', $this->defaultMimeType);
+    $this->assertResponse(400);
+  }
+
+  /**
+   * Try to send no data at all, which does not make sense on POST requests.
+   *
+   * @param $entity_type
+   */
+  public function createEntityNoData($entity_type) {
+    $this->httpRequest('entity/' . $entity_type, 'POST', NULL, $this->defaultMimeType);
+    $this->assertResponse(400);
+  }
 
-    // @todo Add a security test. It should not be possible for example to
-    //   create a test entity on a node resource route.
+  /**
+   * Try to send invalid data to trigger the entity validation constraints. Send a UUID that is too long.
+   *
+   * @param $entity
+   * @param $entity_type
+   * @param array $context
+   */
+  public function createEntityInvalidSerialized($entity, $entity_type, $context = array()) {
+    $entity->set('uuid', $this->randomMachineName(129));
+    $invalid_serialized = $this->serializer->serialize($entity, $this->defaultFormat, $context);
+    $response = $this->httpRequest('entity/' . $entity_type, 'POST', $invalid_serialized, $this->defaultMimeType);
+    $this->assertResponse(422);
+    $error = Json::decode($response);
+    $this->assertEqual($error['error'], "Unprocessable Entity: validation failed.\nuuid.0.value: <em class=\"placeholder\">UUID</em>: may not be longer than 128 characters.\n");
+  }
+
+  /**
+   * Try to create an entity without proper permissions.
+   *
+   * @param $entity_type
+   * @param $serialized
+   */
+  public function createEntityWithoutProperPermissions($entity_type, $serialized) {
+    $this->drupalLogout();
+    $this->httpRequest('entity/' . $entity_type, 'POST', $serialized, $this->defaultMimeType);
+    $this->assertResponse(403);
+    $this->assertFalse(entity_load_multiple($entity_type, NULL, TRUE), 'No entity has been created in the database.');
   }
 
 }
diff --git a/core/modules/rest/src/Tests/RESTTestBase.php b/core/modules/rest/src/Tests/RESTTestBase.php
index 6f90925..1150bfd 100644
--- a/core/modules/rest/src/Tests/RESTTestBase.php
+++ b/core/modules/rest/src/Tests/RESTTestBase.php
@@ -9,7 +9,9 @@
 
 use Drupal\Core\Session\AccountInterface;
 use Drupal\Core\Url;
+use Drupal\node\NodeInterface;
 use Drupal\simpletest\WebTestBase;
+use Drupal\user\UserInterface;
 
 /**
  * Test helper class that provides a REST client method to send HTTP requests.
@@ -351,4 +353,36 @@ protected function loadEntityFromLocationHeader($location_url) {
     return entity_load($this->testEntityType, $id);
   }
 
+  /**
+   * Remove node fields where a non-admin user cannot write to.
+   *
+   * @param NodeInterface $node
+   * @return NodeInterface
+   */
+  protected function removeNodeFieldsForNonAdminUsers(NodeInterface $node) {
+    unset($node->status);
+    unset($node->created);
+    unset($node->changed);
+    unset($node->promote);
+    unset($node->sticky);
+    unset($node->revision_timestamp);
+    unset($node->uid);
+
+    return $node;
+  }
+
+  /**
+   * Remove user fields where a non-admin user cannot write to.
+   *
+   * @param UserInterface $user
+   * @return UserInterface
+   */
+  protected function removeUserFieldsForNonAdminUsers(UserInterface $user) {
+    unset($user->status);
+    unset($user->created);
+    unset($user->changed);
+
+    return $user;
+  }
+
 }
