diff --git a/core/modules/rest/src/Plugin/rest/resource/UserLoginResource.php b/core/modules/rest/src/Plugin/rest/resource/UserLoginResource.php
new file mode 100644
index 0000000..4e1e255
--- /dev/null
+++ b/core/modules/rest/src/Plugin/rest/resource/UserLoginResource.php
@@ -0,0 +1,294 @@
+<?php
+
+namespace Drupal\rest\Plugin\rest\resource;
+
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Flood\FloodInterface;
+use Drupal\rest\ResourceResponse;
+use Drupal\rest\Plugin\ResourceBase;
+use Drupal\user\Entity\User;
+use Drupal\user\UserStorageInterface;
+use Psr\Log\LoggerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+
+/**
+ * Allows user logs in by setting session cookies.
+ *
+ * @RestResource(
+ *   id = "user_login",
+ *   label = @Translation("User Login")
+ * )
+ */
+class UserLoginResource extends ResourceBase {
+
+  /**
+   * The config factory.
+   *
+   * @var \Drupal\Core\Config\ConfigFactoryInterface
+   */
+  protected $configFactory;
+
+  /**
+   * The flood control mechanism.
+   *
+   * @var \Drupal\Core\Flood\FloodInterface
+   */
+  protected $flood;
+
+  /**
+   * The user storage.
+   *
+   * @var \Drupal\user\UserStorageInterface
+   */
+  protected $userStorage;
+
+  /**
+   * A logger instance.
+   *
+   * @var \Psr\Log\LoggerInterface
+   */
+  protected $logger;
+
+  /**
+   * Constructs a new UserLoginResource object.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param array $serializer_formats
+   *   The available serialization formats.
+   * @param \Psr\Log\LoggerInterface $logger
+   *   A logger instance.
+   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
+   *   The config factory.
+   * @param \Drupal\Core\Flood\FloodInterface $flood
+   *   The flood control mechanism.
+   * @param \Drupal\user\UserStorageInterface $user_storage
+   *   The user storage.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, array $serializer_formats, LoggerInterface $logger, ConfigFactoryInterface $config_factory, FloodInterface $flood, UserStorageInterface $user_storage) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $serializer_formats, $logger, $flood);
+    $this->configFactory = $config_factory;
+    $this->flood = $flood;
+    $this->userStorage = $user_storage;
+    $this->logger = $logger;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->getParameter('serializer.formats'),
+      $container->get('logger.factory')->get('rest'),
+      $container->get('config.factory'),
+      $container->get('flood'),
+      $container->get('entity.manager')->getStorage('user')
+    );
+  }
+
+  /**
+   * Responds to the user login POST requests and logs in a user.
+   *
+   * @param string[] $operation
+   *   [
+   *     'op' => 'login', 'logout'
+   *     'credentials' => [
+   *       'name' => 'your-name',
+   *       'pass' => 'your-password',
+   *     ],
+   *   ]
+   *
+   *   The operation and username + pass for the login op.
+   *
+   * @return \Drupal\rest\ResourceResponse
+   *   The HTTP response object.
+   */
+  public function post(array $operation = []) {
+
+    if (array_key_exists('op', $operation)) {
+      switch ($operation['op']) {
+
+        case 'login':
+          if (!array_key_exists('credentials', $operation)) {
+            $operation['credentials'] = [];
+          }
+          return $this->login($operation['credentials']);
+
+        case 'status':
+          return $this->status();
+
+        case 'logout':
+          return $this->logout();
+
+        case 'password_reset':
+          return $this->requestNewPassword($operation['reset_info']);
+
+        default:
+          throw new BadRequestHttpException('Unsupported op '. $operation['op'] . '.');
+
+      }
+    }
+    else {
+      throw new BadRequestHttpException('No op found. Use: status, login, logout.');
+    }
+  }
+
+  /**
+   * User login.
+   *
+   * @param array $credentials
+   *   The username and pass for the user.
+   *
+   * @return \Drupal\rest\ResourceResponse
+   *   The HTTP response object.
+   */
+  protected function login(array $credentials = []) {
+
+    if (empty($credentials)) {
+      throw new BadRequestHttpException('Missing credentials.');
+    }
+
+    // Verify that the username is filled.
+    if (!array_key_exists('name', $credentials)) {
+      throw new BadRequestHttpException('Missing credentials.name.');
+    }
+    // Verify that the password is filled.
+    if (!array_key_exists('pass', $credentials)) {
+      throw new BadRequestHttpException('Missing credentials.pass.');
+    }
+
+    // Flood control.
+    if (!$this->restFloodControl($this->configFactory->get('user.flood'), 'rest.login_cookie')) {
+      throw new BadRequestHttpException('Blocked.');
+    }
+
+    // Verify that the user is not blocked.
+    if ($this->userIsBlocked($credentials['name'])) {
+      throw new BadRequestHttpException('The user has not been activated or is blocked.');
+    }
+
+    // Log in the user.
+    if ($uid = \Drupal::service('user.auth')->authenticate($credentials['name'], $credentials['pass'])) {
+      /** @var \Drupal\user\Entity\User $user */
+      $user = User::load($uid);
+      user_login_finalize($user);
+
+      // Add some basics about the user's account.
+      $response_data = [
+        'current_user' => [
+          'uid' => $user->id(),
+          'roles' => $user->getRoles(),
+          'name' => $user->getAccountName(),
+        ],
+        'csrf_token' => \Drupal::csrfToken()->get('rest'),
+      ];
+
+      return new ResourceResponse($response_data, 200, []);
+    }
+
+    $this->flood->register('rest.login_cookie', $this->configFactory->get('user.flood')->get('user_window'));
+    throw new BadRequestHttpException('Sorry, unrecognized username or password.');
+  }
+
+  /**
+   * Checks if the account is authenticated.
+   *
+   * @return \Drupal\rest\ResourceResponse
+   *   The HTTP response object.
+   */
+  protected function status() {
+    if (\Drupal::currentUser()->isAuthenticated()) {
+      return new ResourceResponse('You are logged in.', 200, []);
+    }
+    return new ResourceResponse('You are not logged in.', 200, []);
+  }
+
+  /**
+   * User Logout.
+   *
+   * @return \Drupal\rest\ResourceResponse
+   *   The HTTP response object.
+   */
+  protected function logout() {
+    user_logout();
+    return new ResourceResponse('You are logged out.', 200, []);
+  }
+
+  /**
+   * Verifies if the user is blocked.
+   *
+   * @param string $name
+   * @return bool
+   */
+  protected function userIsBlocked($name) {
+    return user_is_blocked($name);
+  }
+
+  /**
+   * Sends the replacement login information by email.
+   *
+   * @param array $reset_info
+   *   Necessary data for the replacement.
+   *
+   * @return \Drupal\rest\ResourceResponse
+   *   The HTTP response object.
+   */
+  protected function requestNewPassword(array $reset_info) {
+    $name = $reset_info['name'];
+    // Verify that the email or username is filled.
+    if (!$name) {
+      throw new BadRequestHttpException('Missing Email or Username.');
+    }
+
+    $name = trim($name);
+
+    // Try to load by email.
+    $accounts = $this->userStorage->loadByProperties(['mail' => $name, 'status' => '1']);
+    $account = reset($accounts);
+
+    if (!$account instanceof User) {
+      // No success, try to load by name.
+      $accounts = $this->userStorage->loadByProperties(['name' => $name, 'status' => '1']);
+      $account = reset($accounts);
+    }
+
+    if (!$account instanceof User) {
+      // No success, the user does not exist.
+      throw new BadRequestHttpException("Sorry, $name is not recognized as a user name or an e-mail address.");
+    }
+
+    $mail = _user_mail_notify('password_reset', $account, $reset_info['lang']);
+    if (!empty($mail)) {
+      $this->logger->notice('Password reset instructions mailed to %name at %email.', ['%name' => $account->getUsername(), '%email' => $account->getEmail()]);
+      return new ResourceResponse('Further instructions have been sent to your email address.', 200, []);
+    }
+    throw new BadRequestHttpException('The email with the instructions was not sent as expected.');
+  }
+
+  /**
+   * Checks for flooding.
+   *
+   * @param \Drupal\Core\Config\ImmutableConfig $config
+   *   The flood control config object.
+   * @param string $name
+   *  The name of the event.
+   *
+   * @return bool
+   *   TRUE if the user is allowed to proceed, FALSE otherwise.
+   */
+  protected function restFloodControl($config, $name) {
+    $limit = $config->get('user_limit');
+    $interval = $config->get('user_window');
+
+    return $this->flood->isAllowed($name, $limit, $interval);
+  }
+
+}
diff --git a/core/modules/rest/src/RequestHandler.php b/core/modules/rest/src/RequestHandler.php
index d6b3dcf..e0b589e 100644
--- a/core/modules/rest/src/RequestHandler.php
+++ b/core/modules/rest/src/RequestHandler.php
@@ -59,9 +59,15 @@ public function handle(RouteMatchInterface $route_match, Request $request) {
       $method_settings = $config[$plugin][$request->getMethod()];
       if (empty($method_settings['supported_formats']) || in_array($format, $method_settings['supported_formats'])) {
         $definition = $resource->getPluginDefinition();
-        $class = $definition['serialization_class'];
         try {
-          $unserialized = $serializer->deserialize($received, $class, $format, array('request_method' => $method));
+          if (array_key_exists('serialization_class', $definition)) {
+            $unserialized = $serializer->deserialize($received, $definition['serialization_class'], $format, array('request_method' => $method));
+          }
+          // If the plugin does not specify a serialization class just decode the received data.
+          // Example: received JSON is decoded into a PHP array.
+          else {
+            $unserialized = $serializer->decode($received, $format, array('request_method' => $method));
+          }
         }
         catch (UnexpectedValueException $e) {
           $error['error'] = $e->getMessage();
diff --git a/core/modules/rest/src/Tests/NodeTest.php b/core/modules/rest/src/Tests/NodeTest.php
index 4948900..b55cd0b 100644
--- a/core/modules/rest/src/Tests/NodeTest.php
+++ b/core/modules/rest/src/Tests/NodeTest.php
@@ -180,7 +180,7 @@ public function testInvalidBundle() {
 
     // Make sure the response is "Bad Request".
     $this->assertResponse(400);
-    $this->assertResponseBody('{"error":"\"bad_bundle_name\" is not a valid bundle type for denormalization."}');
+    $this->assertResponseBody(NULL, '{"error":"\"bad_bundle_name\" is not a valid bundle type for denormalization."}');
   }
 
   /**
@@ -197,6 +197,6 @@ public function testMissingBundle() {
 
     // Make sure the response is "Bad Request".
     $this->assertResponse(400);
-    $this->assertResponseBody('{"error":"A string must be provided as a bundle value."}');
+    $this->assertResponseBody(NULL, '{"error":"A string must be provided as a bundle value."}');
   }
 }
diff --git a/core/modules/rest/src/Tests/RESTTestBase.php b/core/modules/rest/src/Tests/RESTTestBase.php
index 185a7e8..18231a6 100644
--- a/core/modules/rest/src/Tests/RESTTestBase.php
+++ b/core/modules/rest/src/Tests/RESTTestBase.php
@@ -82,7 +82,7 @@ protected function setUp() {
    * @return string
    *   The content returned from the request.
    */
-  protected function httpRequest($url, $method, $body = NULL, $mime_type = NULL) {
+  protected function httpRequest($url, $method, $body = NULL, $mime_type = NULL, $request_headers = []) {
     if (!isset($mime_type)) {
       $mime_type = $this->defaultMimeType;
     }
@@ -123,10 +123,11 @@ protected function httpRequest($url, $method, $body = NULL, $mime_type = NULL) {
           CURLOPT_POSTFIELDS => $body,
           CURLOPT_URL => $url,
           CURLOPT_NOBODY => FALSE,
-          CURLOPT_HTTPHEADER => array(
+          CURLOPT_HTTPHEADER => array_merge(
+            array(
             'Content-Type: ' . $mime_type,
             'X-CSRF-Token: ' . $token,
-          ),
+          ), $request_headers),
         );
         break;
 
@@ -178,6 +179,9 @@ protected function httpRequest($url, $method, $body = NULL, $mime_type = NULL) {
 
     $this->verbose($method . ' request to: ' . $url .
       '<hr />Code: ' . curl_getinfo($this->curlHandle, CURLINFO_HTTP_CODE) .
+      '<hr />Request headers: ' . nl2br(print_r($curl_options[CURLOPT_HTTPHEADER], TRUE)) .
+      '<hr />Extra headers: ' . nl2br(print_r($request_headers, TRUE)) .
+      '<hr />Request body: ' . nl2br(print_r($body, TRUE)) .
       '<hr />Response headers: ' . nl2br(print_r($headers, TRUE)) .
       '<hr />Response body: ' . $this->responseBody);
 
@@ -409,6 +413,10 @@ protected function removeNodeFieldsForNonAdminUsers(NodeInterface $node) {
    * Check to see if the HTTP request response body is identical to the expected
    * value.
    *
+   *
+   * @param $code
+   *   (optional) Response code. For example 200 is a successful page request. For a list
+   *   of all codes see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html.
    * @param $expected
    *   The first value to check.
    * @param $message
@@ -425,7 +433,11 @@ protected function removeNodeFieldsForNonAdminUsers(NodeInterface $node) {
    * @return bool
    *   TRUE if the assertion succeeded, FALSE otherwise.
    */
-  protected function assertResponseBody($expected, $message = '', $group = 'REST Response') {
+  protected function assertResponseBody($code = NULL, $expected, $message = '', $group = 'REST Response') {
+    if ($code) {
+      $this->assertResponse($code);
+    }
     return $this->assertIdentical($expected, $this->responseBody, $message ? $message : strtr('Response body @expected (expected) is equal to @response (actual).', array('@expected' => var_export($expected, TRUE), '@response' => var_export($this->responseBody, TRUE))), $group);
   }
+
 }
diff --git a/core/modules/rest/src/Tests/ResourceTest.php b/core/modules/rest/src/Tests/ResourceTest.php
index 50521cb..527af9b 100644
--- a/core/modules/rest/src/Tests/ResourceTest.php
+++ b/core/modules/rest/src/Tests/ResourceTest.php
@@ -117,8 +117,10 @@ public function testUriPaths() {
     $manager = \Drupal::service('plugin.manager.rest');
 
     foreach ($manager->getDefinitions() as $resource => $definition) {
-      foreach ($definition['uri_paths'] as $key => $uri_path) {
-        $this->assertFalse(strpos($uri_path, '//'), 'The resource URI path does not have duplicate slashes.');
+      if (isset($definition['uri_paths'])) {
+        foreach ($definition['uri_paths'] as $key => $uri_path) {
+          $this->assertFalse(strpos($uri_path, '//'), 'The resource URI path does not have duplicate slashes.');
+        }
       }
     }
   }
diff --git a/core/modules/rest/src/Tests/UserLoginTest.php b/core/modules/rest/src/Tests/UserLoginTest.php
new file mode 100644
index 0000000..fb40dbc
--- /dev/null
+++ b/core/modules/rest/src/Tests/UserLoginTest.php
@@ -0,0 +1,120 @@
+<?php
+
+namespace Drupal\rest\Tests;
+
+use Drupal\user\Entity\Role;
+use Drupal\user\RoleInterface;
+
+/**
+ * Tests REST user login.
+ *
+ * @group rest
+ */
+class UserLoginTest extends RESTTestBase {
+
+  /**
+   * Test user session life cycle.
+   */
+  public function testLogin() {
+    // Enable the service.
+    $config = $this->config('rest.settings');
+    $settings = [];
+    $resource = ['type' => 'user_login', 'method' => 'POST'];
+    $format = 'json';
+    $auth = $this->defaultAuth;
+    $settings[$resource['type']][$resource['method']]['supported_formats'][] = $format;
+    $settings[$resource['type']][$resource['method']]['supported_auth'] = $auth;
+    $config->set('resources', $settings);
+    $config->save();
+
+    $this->rebuildCache();
+
+    $permissions[] = 'restful post user_login';
+    $account = $this->drupalCreateUser($permissions);
+    $name = $account->getUsername();
+    $pass = $account->pass_raw;
+
+    // Add login permission to anonymous user.
+    Role::load(RoleInterface::ANONYMOUS_ID)
+      ->grantPermission('restful post user_login')
+      ->save();
+
+    $payload = array();
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"No op found. Use: status, login, logout."}');
+
+    $payload = $this->getPayload('garbage');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"Unsupported op garbage."}');
+
+    $payload = $this->getPayload('status');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('200', '"You are not logged in."');
+
+    $payload = $this->getPayload('login');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"Missing credentials."}');
+
+    $payload = $this->getPayload('login', $name);
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"Missing credentials.pass."}');
+
+    $payload = $this->getPayload('login', NULL, $pass);
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"Missing credentials.name."}');
+
+    $payload = $this->getPayload('login', $name, 'garbage');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"Sorry, unrecognized username or password."}');
+
+    $payload = $this->getPayload('login', 'garbage', $pass);
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('400', '{"error":"Sorry, unrecognized username or password."}');
+
+    $payload = $this->getPayload('login', $name, $pass);
+    $response = $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $response = json_decode($response);
+    $this->assertEqual($name, $response->current_user->name, "The user name is correct.");
+
+    $payload = $this->getPayload('status');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('200', '"You are logged in."');
+
+    $payload = $this->getPayload('logout');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('200', '"You are logged out."');
+
+    $payload = $this->getPayload('status');
+    $this->httpRequest('user_login', 'POST', json_encode($payload), 'application/json');
+    $this->assertResponseBody('200', '"You are not logged in."');
+
+  }
+
+  /**
+   * Helper function to build the payload.
+   *
+   * @param string $op
+   *   The operation.
+   * @param string $name
+   *   The user name.
+   * @param string $pass
+   *   The user pass.
+   *
+   * @return array
+   *   The payload.
+   */
+  private function getPayload( $op, $name = NULL, $pass = NULL) {
+    $result = array('op' => $op);
+
+    if ($op == 'login') {
+      $result['credentials'] = array();
+      if (isset($name)) {
+        $result['credentials']['name'] = $name;
+      }
+      if (isset($pass)) {
+        $result['credentials']['pass'] = $pass;
+      }
+    }
+    return $result;
+  }
+}
diff --git a/core/modules/rest/tests/src/Unit/UserLoginResourceTest.php b/core/modules/rest/tests/src/Unit/UserLoginResourceTest.php
new file mode 100644
index 0000000..d7e2445
--- /dev/null
+++ b/core/modules/rest/tests/src/Unit/UserLoginResourceTest.php
@@ -0,0 +1,239 @@
+<?php
+
+namespace Drupal\Tests\rest\Unit;
+
+use Drupal\Core\DependencyInjection\ContainerBuilder;
+use Drupal\rest\Plugin\rest\resource\UserLoginResource;
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Tests the Login Resource.
+ * @TODO Test flood control after https://www.drupal.org/node/2431357 has landed.
+ * @group rest
+ */
+class UserLoginResourceTest extends UnitTestCase {
+
+  /**
+   * The resource to be tested.
+   *
+   * @var \Drupal\rest\Plugin\rest\resource\UserLoginResource
+   */
+  protected $testClass;
+
+  /**
+   * The flood control mechanism.
+   *
+   * @var \Drupal\Core\Flood\FloodInterface
+   */
+  protected $flood;
+
+  /**
+   * A logger instance.
+   *
+   * @var \Psr\Log\LoggerInterface
+   */
+  protected $logger;
+
+  /**
+   * A reflection of self::$translation.
+   *
+   * @var \ReflectionClass
+   */
+  protected $reflection;
+
+  /**
+   * Config.
+   *
+   * @var \Drupal\Core\Config\Config
+   */
+  protected $config;
+
+  /**
+   * The resource to be tested as a mock object.
+   *
+   * @var \PHPUnit_Framework_MockObject_MockBuilder
+   */
+  protected $testClassMock;
+
+  /**
+   * The user storage.
+   *
+   * @var \Drupal\user\UserStorageInterface
+   */
+  protected $userStorage;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $user_auth_service = $this->getMock('Drupal\user\UserAuthInterface');
+    $user_auth_service->expects($this->any())
+      ->method('authenticate')
+      ->will($this->returnValue(FALSE));
+
+    $container = new ContainerBuilder();
+    $container->set('user.auth', $user_auth_service);
+    \Drupal::setContainer($container);
+
+    $this->flood = $this->getMock('\Drupal\Core\Flood\FloodInterface');
+
+    $this->userStorage = $this->getMockBuilder('\Drupal\user\UserStorage')
+      ->disableOriginalConstructor()
+      ->getMock();
+
+    $this->config = $this->getMockBuilder('\Drupal\Core\Config\ConfigFactory')
+      ->disableOriginalConstructor()
+      ->setMethods(['get'])
+      ->getMock();
+
+    $immutableConfig = $this->getMockBuilder('\Drupal\Core\Config\ConfigFactory')
+      ->disableOriginalConstructor()
+      ->setMethods(['get'])
+      ->getMock();
+
+    $this->config->expects($this->any())
+      ->method('get')
+      ->will($this->returnValue($immutableConfig));
+
+    $this->logger = $this->getMock('Psr\Log\LoggerInterface');
+
+    $this->testClass = new UserLoginResource([], 'plugin_id', '', [], $this->logger, $this->config,  $this->flood, $this->userStorage);
+
+    $this->testClassMock = $this->getMockBuilder('\Drupal\rest\Plugin\rest\resource\UserLoginResource')
+      ->setMethods(['restFloodControl', 'login', 'logout', 'post', 'userIsBlocked'])
+      ->setConstructorArgs([[], 'plugin_id', '', [], $this->logger, $this->config,  $this->flood, $this->userStorage])
+      ->getMock();
+
+    $this->reflection = new \ReflectionClass($this->testClass);
+  }
+
+  /**
+   * Gets a protected method from current class using reflection.
+   *
+   * @param string $method
+   *   The requested method.
+   *
+   * @return mixed
+   *   The protected method.
+   */
+  public function getProtectedMethod($method) {
+    $method = $this->reflection->getMethod($method);
+    $method->setAccessible(TRUE);
+
+    return $method;
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage No op found. Use: status, login, logout.
+   */
+  public function testEmptyPayload() {
+    $this->testClass->post([]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Missing credentials.
+   */
+  public function testMissingCredentials() {
+    $this->testClass->post(['op'=>'login']);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Unsupported op UnsuportedOp.
+   */
+  public function testUnsupportedOp() {
+    $this->testClass->post(['op'=>'UnsuportedOp']);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Missing credentials.
+   */
+  public function testLoginMissingCredentialName() {
+    $method = $this->getProtectedMethod('login');
+    $method->invokeArgs($this->testClass, ['credentials' => []]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Missing credentials.pass.
+   */
+  public function testLoginMissingCredentialPass() {
+    $method = $this->getProtectedMethod('login');
+    $method->invokeArgs($this->testClass, ['credentials' => ['name' => 'Druplicon']]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Blocked.
+   */
+  public function testLoginBlockedUserByFloodControl() {
+    $this->testClassMock->expects($this->once())
+      ->method('restFloodControl')
+      ->will($this->returnValue(FALSE));
+
+    $method = $this->getProtectedMethod('login');
+    $method->invokeArgs($this->testClassMock, ['credentials' => ['name' => 'Druplicon', 'pass' => 'SuperSecret']]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage The user has not been activated or is blocked.
+   */
+  public function testLoginBlockedUser() {
+    $this->testClassMock->expects($this->once())
+      ->method('restFloodControl')
+      ->will($this->returnValue(TRUE));
+
+    $this->testClassMock->expects($this->once())
+      ->method('userIsBlocked')
+      ->will($this->returnValue(TRUE));
+
+    $method = $this->getProtectedMethod('login');
+    $method->invokeArgs($this->testClassMock, ['credentials' => ['name' => 'Druplicon', 'pass' => 'SuperSecret']]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Sorry, unrecognized username or password.
+   */
+  public function testLoginUnrecognizedUsernameOrPassword() {
+    $this->testClassMock->expects($this->once())
+      ->method('restFloodControl')
+      ->will($this->returnValue(TRUE));
+
+    $this->testClassMock->expects($this->once())
+      ->method('userIsBlocked')
+      ->will($this->returnValue(FALSE));
+
+    $method = $this->getProtectedMethod('login');
+    $method->invokeArgs($this->testClassMock, ['credentials' => ['name' => 'Druplicon', 'pass' => 'SuperSecret']]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Missing Email or Username.
+   */
+  public function testResetPasswordMissingNameOrEmail() {
+    $method = $this->getProtectedMethod('requestNewPassword');
+    $method->invokeArgs($this->testClass, [['name' => '']]);
+  }
+
+  /**
+   * @expectedException \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   * @expectedExceptionMessage Sorry, Druplicon is not recognized as a user name or an e-mail address.
+   */
+  public function testResetPasswordNotRecognizedNameOrEmail() {
+    $this->userStorage->expects($this->any())
+      ->method('loadByProperties')
+      ->will($this->returnValue([]));
+
+    $method = $this->getProtectedMethod('requestNewPassword');
+    $method->invokeArgs($this->testClass, [['name' => 'Druplicon']]);
+  }
+}
+