Merge lp:~jkakar/todo/login-command into lp:todo

[Jamu Kakar]

This branch introduces the following changes:

- A bunch of testing support has been added in a new todo.testing
  package. There's a TodoTestCase with support for using test
  resources and for testing Twisted-based code. There's a also a
  todo.doubles module with a FakeEndpoint that can be used to write
  tests for code that use txFluidDB. The MockEndpoint in txFluidDB
  itself isn't useful, unfortunately, because it only allows one
  response to be mocked at a time. At some point soon we'll need more
  than that.

- A new todo.application module contains helper functions to get the
  default path for configuration data and to create the default
  endpoint.

- A new todo.model module contains the beginnings of a model layer.
  So far it has a login function and an empty Person class (which I
  expect to eventually expose methods like 'create_task',
  'create_category', etc.)

- A new todo.commands module contains a new 'login' command. It uses
  the model layer to perform actual authentication and takes care of
  writing credentials to disk (which I guess is specific to the CLI
  interface).

Hopefully subsequent branches will be a bit easier to push forward,
now that testing support is in place. The 'login' command doesn't
create a namespace for tasks yet. I decided to defer that to a
subsequent branch, since this one is already getting a bit big.

[Jamu Kakar (jkakar)]

Just had a thought, which I'll record here so I don't forget it:

It'd be nice to add a test to ensure that cached credentials are
completely rewritten when the 'login' command is run more than once.

[Jamu Kakar (jkakar)]

Actually, thinking about this more, the call to /user/<username>
doesn't actually do any validation of the password... does it? Maybe
this branch isn't ready for review. Would appreciate a scan and some
advice about what to do in the todo.model.login function.

[lp:~jkakar/todo/login-command]

19. By Jamu Kakar on 2011-01-23

- Fixed typo in test.

[Jamu Kakar (jkakar)]

After talking with Terry on IRC I realize the previous question
doesn't make sense. Things should be fine.

[Terry Jones (terrycojones)]

The above question was answered (yes) in IRC just now.

[Jamu Kakar (jkakar)]

Ah, just realized something... even though the credentials are being
checked, I haven't verified that the HTTP response when they're
invalid or for an unknown user are the same as what I'm using in the
test. That should be done before this branch is merged.

Unmerged revisions

19. By Jamu Kakar on 2011-01-23

- Fixed typo in test.

18. By Jamu Kakar on 2011-01-23

- Fixed type in program name.

17. By Jamu Kakar on 2011-01-23

- Added a todo.commands module with a 'login' command that
  authenticates a user against FluidDB and writes credentials to disk.

16. By Jamu Kakar on 2011-01-23

- Add a new todo.model module with a login function and the beginnings
  of a Person model class.

15. By Jamu Kakar on 2011-01-23

- A new todo.testing.doubles module contains a FakeEndpoint (and
  FakeRequest) that can be used to test code that uses txFluidDB.

14. By Jamu Kakar on 2011-01-23

- Updated TodoTestCase to work for Twisted-based code.

13. By Jamu Kakar on 2011-01-23

- Added a new todo.application module with functions to get the
  configuration path and create a default txfluiddb.client.Endpoint.

12. By Jamu Kakar on 2011-01-23

- Added todo.tests package.

11. By Jamu Kakar on 2011-01-22

- Add a new todo.testing package to contain support for the test
  suite. A TodoTestCase combines the testresources and testtools test
  case classes.

10. By Jamu Kakar on 2011-01-22

- Added 'commandant' to the requires list in setup.py.

=== added file 'todo/application.py'
--- todo/application.py	1970-01-01 00:00:00 +0000
+++ todo/application.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,41 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+import os
+
+from txfluiddb.client import Endpoint, BasicCreds
+
+
+def get_config_path():
+    """Get the location to use when reading or writing configuration data.
+
+    Todo stores configuration data in C{$HOME/.config/todo}.  It will be
+    created automatically if it doesn't exist.
+
+    @return: The directory for configuration data.
+    """
+    base_path = os.environ["HOME"]
+    path = os.path.join(base_path, ".config/todo")
+    if not os.path.exists(path):
+        os.makedirs(path)
+    return path
+
+
+def create_default_endpoint(username, password):
+    """
+    Create a C{txfluiddb.client.Endpoint} instance configured using the
+    specified C{username} and C{password} and the default FluidDB API URL.
+    """
+    credentials = BasicCreds(username, password)
+    return Endpoint(creds=credentials)

=== added file 'todo/commands.py'
--- todo/commands.py	1970-01-01 00:00:00 +0000
+++ todo/commands.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,57 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+from getpass import getpass
+import os
+
+from commandant.commands import TwistedCommand
+
+from todo.application import create_default_endpoint, get_config_path
+from todo.model import InvalidCredentialsError, UnknownUserError, login
+
+
+class cmd_login(TwistedCommand):
+    """Authenticate with FluidDB and cache credentials locally."""
+
+    endpoint_factory = None
+    takes_args = ["username"]
+
+    def run(self, username):
+        password = getpass("Password: ")
+        endpoint = self.create_endpoint(username, password)
+        deferred = login(endpoint)
+
+        def write_credentials(person):
+            credentials_path = os.path.join(get_config_path(),
+                                            "credentials.txt")
+            with open(credentials_path, "w") as file:
+                file.write(person.endpoint.creds.encode())
+
+        def print_error(failure):
+            failure.trap(InvalidCredentialsError, UnknownUserError)
+            self.outf.write(failure.getErrorMessage())
+
+        deferred.addCallback(write_credentials)
+        deferred.addErrback(print_error)
+        return deferred
+
+    def create_endpoint(self, username, password):
+        """
+        Get a C{txfluiddb.client.Endpoint} instance to use when interacting
+        with FluidDB.
+        """
+        if self.endpoint_factory:
+            return self.endpoint_factory(username, password)
+        else:
+            return create_default_endpoint(username, password)

=== modified file 'todo/entry_point.py'
--- todo/entry_point.py	2011-01-23 23:29:09 +0000
+++ todo/entry_point.py	2011-01-23 23:29:09 +0000
@@ -18,6 +18,7 @@
 from commandant.controller import CommandController
 
 from todo import __version__
+from todo import commands
 
 
 def main(argv):
@@ -32,10 +33,11 @@
     if len(argv) < 2:
         argv.append("help")
 
-    controller = CommandController("todo", __version__,
+    controller = CommandController("td", __version__,
                                    "Todo is a task tracker for teams!",
                                    "https://launchpad.net/todo")
     controller.load_module(builtins)
+    controller.load_module(commands)
     controller.install_bzrlib_hooks()
     try:
         controller.run(argv[1:])

=== added file 'todo/model.py'
--- todo/model.py	1970-01-01 00:00:00 +0000
+++ todo/model.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,57 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+from urllib import basejoin
+
+
+class InvalidCredentialsError(Exception):
+    """Raised when invalid credentials are provided."""
+
+
+class UnknownUserError(Exception):
+    """Raised when credentials don't match a user in FluidDB."""
+
+
+def login(endpoint):
+    """Authenticate a L{Person} against FluidDB.
+
+    @param endpoint: A C{txfluiddb.client.Endpoint} instance that can be used
+        to authenticate with FluidDB.
+    @raises UnknownUserError: The C{Deferred} will fire an errback if the
+        specified credentials are invalid.
+    @return: A C{Deferred} that will fire with a L{Person} instance.
+    """
+    url = basejoin(endpoint.getRootURL(), "/user/%s" % endpoint.creds.username)
+    deferred = endpoint.submit(url, "GET", parsePayload=False)
+
+    def handle_response((status, headers, data)):
+        if status == 200:
+            return Person(endpoint)
+        elif status == 404:
+            raise UnknownUserError("Unknown user.")
+        elif status == 400:
+            raise InvalidCredentialsError("Invalid credentials.")
+
+    return deferred.addCallback(handle_response)
+
+
+class Person(object):
+    """The primary actor, a person creating and modifying tasks.
+
+    @param endpoint: A C{txfluiddb.client.Endpoint} instance that can be used
+        to interact with FluidDB on behalf of the person.
+    """
+
+    def __init__(self, endpoint):
+        self.endpoint = endpoint

=== added directory 'todo/testing'
=== added file 'todo/testing/__init__.py'
--- todo/testing/__init__.py	1970-01-01 00:00:00 +0000
+++ todo/testing/__init__.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,15 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+"""Testing support such as test case classes, doubles, etc."""

=== added file 'todo/testing/basic.py'
--- todo/testing/basic.py	1970-01-01 00:00:00 +0000
+++ todo/testing/basic.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,27 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+from testresources import ResourcedTestCase
+from twisted.trial.unittest import TestCase
+
+
+class TodoTestCase(TestCase, ResourcedTestCase):
+
+    def setUp(self):
+        TestCase.setUp(self)
+        ResourcedTestCase.setUp(self)
+
+    def tearDown(self):
+        TestCase.tearDown(self)
+        ResourcedTestCase.tearDown(self)

=== added file 'todo/testing/doubles.py'
--- todo/testing/doubles.py	1970-01-01 00:00:00 +0000
+++ todo/testing/doubles.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,87 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+from urllib import basejoin
+
+from twisted.internet.defer import succeed
+from txfluiddb.client import Endpoint
+
+
+class FakeRequest(object):
+    """A fake request for testing purposes.
+
+    @param url: The URL for this request.
+    @param method: The HTTP method for this request.
+    @param data: The HTTP payload for this request.
+    @param headers: A C{dict} containing HTTP request headers.
+    """
+
+    def __init__(self, url, method, data=None, headers=None):
+        self.url = url
+        self.method = method
+        self.data = data
+        self.headers = headers
+
+    def respond(self, data, headers=None, code=None):
+        """Record the response that will be sent when the request is made.
+
+        @param data: The HTTP response payload.
+        @param headers: A C{dict} containing HTTP response headers.  Defaults
+            to an empty C{dict}.
+        @param code: The HTTP status code.  Defaults to 200.
+        """
+        self._response_data = data
+        self._response_headers = headers if headers else {}
+        self._response_code = code if code else 200
+
+    def get_response(self):
+        """Get the response code, headers and data as a 3-tuple."""
+        return (self._response_code, self._response_headers,
+                self._response_data)
+
+
+class FakeEndpoint(Endpoint):
+    """A fake C{txfluiddb.client.Endpoint} for testing purposes."""
+
+    requests = []
+
+    def getPage(self, url, method, postdata=None, headers=None,
+                *args, **kwargs):
+        """Return fake results instead of submitting a request."""
+        request = self.requests.pop(0)
+        if request.url != url:
+            raise RuntimeError("Expected URL '%s' but got '%s'."
+                               % (request.url, url))
+        if request.method != method:
+            raise RuntimeError("Expected method '%s' but got '%s'."
+                               % (request.method, method))
+        if request.data != postdata:
+            raise RuntimeError("Expected data '%s' but got '%s'."
+                               % (request.data, postdata))
+        if request.headers != headers:
+            raise RuntimeError("Expected headers '%s' but got '%s'."
+                               % (request.headers, headers))
+        return succeed(request.get_response())
+
+    def expect(self, path, method, data=None, headers=None):
+        """Record an expectation of an HTTP request.
+
+        @return: A L{FakeRequest} instance representing the request.
+        """
+        if method == "GET" and data is not None:
+            raise RuntimeError("GET requests should never include POST data.")
+        url = basejoin(self.getRootURL(), path)
+        request = FakeRequest(url, method, data, headers)
+        self.requests.append(request)
+        return request

=== added directory 'todo/tests'
=== added file 'todo/tests/__init__.py'
--- todo/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ todo/tests/__init__.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,15 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+"""Unit tests for L{todo}."""

=== added file 'todo/tests/test_application.py'
--- todo/tests/test_application.py	1970-01-01 00:00:00 +0000
+++ todo/tests/test_application.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,62 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+import os
+
+from commandant.testing.resources import TemporaryDirectoryResource
+from txfluiddb.client import FLUIDDB_ENDPOINT
+
+from todo.application import get_config_path, create_default_endpoint
+from todo.testing.basic import TodoTestCase
+
+
+class GetConfigPathTest(TodoTestCase):
+
+    resources = [("fs", TemporaryDirectoryResource())]
+
+    def setUp(self):
+        super(GetConfigPathTest, self).setUp()
+        self.addCleanup(os.putenv, "HOME", os.environ["HOME"])
+        os.environ["HOME"] = self.fs.make_dir()
+
+    def test_get_config_path(self):
+        """L{get_config_path} will returns the path for configuration data."""
+        expected_path = os.path.join(os.environ["HOME"], ".config/todo")
+        os.makedirs(expected_path)
+        self.assertTrue(os.path.exists(expected_path))
+        self.assertEqual(expected_path, get_config_path())
+
+    def test_get_config_path_creates_path(self):
+        """
+        L{get_config_path} creates the configuration directory, if it doesn't
+        exist.
+        """
+        expected_path = os.path.join(os.environ["HOME"], ".config/todo")
+        self.assertFalse(os.path.exists(expected_path))
+        self.assertEqual(expected_path, get_config_path())
+        self.assertTrue(os.path.exists(expected_path))
+
+
+class CreateDefaultEndpointTest(TodoTestCase):
+
+    def test_create_default_endpoint(self):
+        """
+        L{create_default_endpoint} returns a C{txfluiddb.client.Endpoint},
+        configured to use the specified username, password and FluidDB API
+        URL.
+        """
+        endpoint = create_default_endpoint("username", "password")
+        self.assertEqual(FLUIDDB_ENDPOINT, endpoint.baseURL)
+        self.assertEqual("username", endpoint.creds.username)
+        self.assertEqual("password", endpoint.creds.password)

=== added file 'todo/tests/test_commands.py'
--- todo/tests/test_commands.py	1970-01-01 00:00:00 +0000
+++ todo/tests/test_commands.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,126 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+from getpass import getpass
+from json import dumps
+import os
+
+from commandant.testing.mocker import MockerResource
+from commandant.testing.resources import (
+    CommandFactoryResource, TemporaryDirectoryResource)
+from txfluiddb.client import BasicCreds, FLUIDDB_ENDPOINT
+
+from todo.application import get_config_path
+from todo.commands import cmd_login
+from todo.testing.basic import TodoTestCase
+from todo.testing.doubles import FakeEndpoint
+
+
+class LoginCommandTest(TodoTestCase):
+
+    resources = [("factory", CommandFactoryResource()),
+                 ("fs", TemporaryDirectoryResource()),
+                 ("mocker", MockerResource())]
+
+    def setUp(self):
+        super(LoginCommandTest, self).setUp()
+        self.addCleanup(os.putenv, "HOME", os.environ["HOME"])
+        os.environ["HOME"] = self.fs.make_dir()
+        self.credentials = BasicCreds("username", "password")
+        self.endpoint = FakeEndpoint("http://fluiddb.example.com",
+                                     creds=self.credentials)
+        self.command = self.factory.create_command("login", cmd_login)
+        self.command.endpoint_factory = lambda *args: self.endpoint
+
+    def test_default_endpoint(self):
+        """
+        The default endpoint is a C{txfluiddb.client.Endpoint} instances
+        configured with the specified username, password and FluidDB API URL.
+        """
+        command = self.factory.create_command("login", cmd_login)
+        endpoint = command.create_endpoint("username", "password")
+        self.assertEqual(FLUIDDB_ENDPOINT, endpoint.baseURL)
+        self.assertEqual("username", endpoint.creds.username)
+        self.assertEqual("password", endpoint.creds.password)
+
+    def test_login(self):
+        """
+        The password specified by the user is used to authenticate with
+        FluidDB.
+        """
+        getpass_mock = self.mocker.replace(getpass, passthrough=False)
+        getpass_mock("Password: ")
+        self.mocker.result("password")
+        self.mocker.replay()
+
+        request = self.endpoint.expect(
+            "/user/username", "GET",
+            headers={"Authorization": self.credentials.encode()})
+        request.respond(dumps({"name": "Test User",
+                               "id": "492d803f-f36c-459c-9c49-9f8dff0af3c1"}))
+
+        def check(_):
+            credentials_path = os.path.join(get_config_path(),
+                                            "credentials.txt")
+            with open(credentials_path, "r") as file:
+                self.assertEqual(self.endpoint.creds.encode(), file.read())
+
+        return self.command.run("username").addCallback(check)
+
+    def test_login_with_unknown_user(self):
+        """
+        An error message is displayed if the specified credentials don't match
+        a user in FluidDB.
+        """
+        getpass_mock = self.mocker.replace(getpass, passthrough=False)
+        getpass_mock("Password: ")
+        self.mocker.result("password")
+        self.mocker.replay()
+
+        request = self.endpoint.expect(
+            "/user/username", "GET",
+            headers={"Authorization": self.credentials.encode()})
+        request.respond("Unknown user.", code=404)
+
+        def check(_):
+            credentials_path = os.path.join(get_config_path(),
+                                            "credentials.txt")
+            self.assertFalse(os.path.exists(credentials_path))
+            self.assertEqual("Unknown user.", self.command.outf.getvalue())
+
+        return self.command.run("username").addCallback(check)
+
+    def test_login_with_invalid_credentials(self):
+        """
+        An error message is displayed if the specified credentials are
+        invalid.
+        """
+        getpass_mock = self.mocker.replace(getpass, passthrough=False)
+        getpass_mock("Password: ")
+        self.mocker.result("password")
+        self.mocker.replay()
+
+        request = self.endpoint.expect(
+            "/user/username", "GET",
+            headers={"Authorization": self.credentials.encode()})
+        request.respond("Invalid credentials.", code=400)
+
+        def check(_):
+            credentials_path = os.path.join(get_config_path(),
+                                            "credentials.txt")
+            self.assertFalse(os.path.exists(credentials_path))
+            self.assertEqual("Invalid credentials.",
+                             self.command.outf.getvalue())
+
+        return self.command.run("username").addCallback(check)

=== added file 'todo/tests/test_model.py'
--- todo/tests/test_model.py	1970-01-01 00:00:00 +0000
+++ todo/tests/test_model.py	2011-01-23 23:29:09 +0000
@@ -0,0 +1,81 @@
+# Todo is a task tracker for teams!
+# Copyright (C) 2011 Jamshed Kakar <[e-mail]> and Nicholas Tollervey
+# <[e-mail]>.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+
+from json import dumps
+
+from txfluiddb.client import BasicCreds
+
+from todo.model import InvalidCredentialsError, UnknownUserError, login
+from todo.testing.basic import TodoTestCase
+from todo.testing.doubles import FakeEndpoint
+
+
+class LoginTest(TodoTestCase):
+
+    def setUp(self):
+        super(LoginTest, self).setUp()
+        self.credentials = BasicCreds("username", "password")
+        self.endpoint = FakeEndpoint("http://example.com",
+                                     creds=self.credentials)
+
+    def test_login(self):
+        """
+        L{login} returns a L{Person} instance if the specified endpoint
+        contains valid credentials that are successfully authenticated against
+        FluidDB.
+        """
+        request = self.endpoint.expect(
+            "/user/username", "GET",
+            headers={"Authorization": self.credentials.encode()})
+        request.respond(dumps({"name": "Test User",
+                               "id": "492d803f-f36c-459c-9c49-9f8dff0af3c1"}))
+
+        def check(person):
+            self.assertIdentical(self.endpoint, person.endpoint)
+
+        return login(self.endpoint).addCallback(check)
+
+    def test_login_as_unknown_user(self):
+        """
+        An L{UnknownUserError} is returned if the specified endpoint
+        contains credentials for an unknown user in FluidDB.
+        """
+        request = self.endpoint.expect(
+            "/user/username", "GET",
+            headers={"Authorization": self.credentials.encode()})
+        request.respond("Unknown user.", code=404)
+
+        def check(error):
+            self.assertEqual("Unknown user.", str(error))
+
+        deferred = login(self.endpoint)
+        self.assertFailure(deferred, UnknownUserError)
+        return deferred.addCallback(check)
+
+    def test_login_with_invalid_credentials(self):
+        """
+        An L{InvalidCredentialsError} is returned if the specified endpoint
+        contains credentials that aren't valid for a user in FluidDB.
+        """
+        request = self.endpoint.expect(
+            "/user/username", "GET",
+            headers={"Authorization": self.credentials.encode()})
+        request.respond("Invalid credentials.", code=400)
+
+        def check(error):
+            self.assertEqual("Invalid credentials.", str(error))
+
+        deferred = login(self.endpoint)
+        self.assertFailure(deferred, InvalidCredentialsError)
+        return deferred.addCallback(check)