Merge lp:~leonardr/launchpadlib/remove-broken-code into lp:launchpadlib

[Leonard Richardson]

Early this year I spent some time writing some "fake web browser" code for launchpadlib. This code would take a user's Launchpad username and password, log in to Launchpad for them, and go through the motions of authorizing a request token.

I wrote the fake browser code because every single one of our third-party developers was looking at our system and writing their own fake browser code. If we have to have fake browser code, I thought, better that it should all be in one place.

Shortly after I wrote this code, it broke. It broke because we stopped processing logins through Launchpad and started using the Ubuntu Single Sign-On service. I could have changed the fake browser to go through USSO, but since we want Launchpad to become an OpenID consumer, that would do nothing but push off (at great expense) the day when the whole "fake web browser" thing breaks for good.

Benji and I are now completing an alternative to the system that made our developers want to write fake browser code. In the meantime, it turns out that the very presence of this broken code has been confusing developers and making them write code that's broken in new and interesting ways. I'm taking this opportunity to remove the code from Launchpad.

When you look at this branch, your first reaction will be "he's removing all this code and tests and not replacing it with anything"! Keep in mind that this code is all *broken*. RequestTokenAuthorizationEngine and TrustedTokenAuthorizationConsoleApp assumes a workflow that doesn't exist anymore. The test of DummyAuthorizeRequestTokenWithBrowser wasn't testing that the token was actually authorized (it's not, anymore), only that an attempt was made--that's why I had to comment that test out.

The SimulatedLaunchpadBrowser is an interesting case. That code does appear to work! The tests still pass! And because of that, TrustedTokenAuthorizationConsoleApp and RequestTokenAuthorizationEngine appear to work. But this code only works for *users like us*. Old-school users who created their Launchpad accounts before we started using USSO. These are users who have hashed passwords stored in the Launchpad database, such that Launchpad can process HTTP Basic Auth requests for them. A user who created their account within the past few months will not be able to use any of this code.

This is really bad. I've seen at least one developer copy SimulatedLaunchpadBrowser's Basic Auth idea for their own fake-browser code, and then I had to spend quite a bit of time understanding why it appeared to work for some users but not others. I think the best solution is to remove this code from launchpadlib altogether, even though it means we can no longer test the end-to-end process of obtaining an access token.

I'm leaving RequestTokenAuthorizationEngine in (but removing almost all the code), even though there's now only one implementation, because we do plan to come up with another implementation eventually. (One that asks for your USSO password if you use USSO, and opens a web browser otherwise.)

[lp:~leonardr/launchpadlib/remove-broken-code]

98. By Leonard Richardson on 2010-10-20

Removed the no-longer-used DummyAuthorizeRequestTokenWithBrowser class.

[Jelmer Vernooij (jelmer)]

review: Approve (code)

=== modified file 'src/launchpadlib/NEWS.txt'
--- src/launchpadlib/NEWS.txt	2010-08-23 19:51:55 +0000
+++ src/launchpadlib/NEWS.txt	2010-10-20 13:56:48 +0000
@@ -2,6 +2,12 @@
 NEWS for launchpadlib
 =====================
 
+1.7.0 (Unreleased)
+==================
+
+- Removed "fake Launchpad browser" code that didn't work and was
+  misleading developers.
+
 1.6.5 (2010-08-23)
 ==================
 
 
=== modified file 'src/launchpadlib/__init__.py'
--- src/launchpadlib/__init__.py	2010-08-23 19:51:55 +0000
+++ src/launchpadlib/__init__.py	2010-10-20 13:56:48 +0000
@@ -14,4 +14,4 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with launchpadlib. If not, see <http://www.gnu.org/licenses/>.
 
-__version__ = '1.6.5'
+__version__ = '1.7.0'
 
=== modified file 'src/launchpadlib/apps.py'
--- src/launchpadlib/apps.py	2009-11-02 12:20:47 +0000
+++ src/launchpadlib/apps.py	2010-10-20 13:56:48 +0000
@@ -52,122 +52,3 @@
         return simplejson.dumps(token)
 
 
-class TrustedTokenAuthorizationConsoleApp(RequestTokenAuthorizationEngine):
-    """An application that authorizes request tokens."""
-
-    def __init__(self, web_root, consumer_name, request_token,
-                 access_levels='', input_method=raw_input):
-        """Constructor.
-
-        :param access_levels: A string of comma-separated access level
-        values.  To get an up-to-date list of access levels, pass
-        token_format=Credentials.DICT_TOKEN_FORMAT into
-        Credentials.get_request_token, load the dict as JSON, and look
-        in 'access_levels'.
-        """
-        access_levels = [level.strip() for level in access_levels.split(',')]
-        super(TrustedTokenAuthorizationConsoleApp, self).__init__(
-            web_root, consumer_name, request_token, access_levels)
-
-        self.input_method = input_method
-
-    def run(self):
-        """Try to authorize a request token from user input."""
-        self.error_code = -1 # Start off assuming failure.
-        start = "Launchpad credential client (console)"
-        self.output(start)
-        self.output("-" * len(start))
-
-        try:
-            self()
-        except TokenAuthorizationException, e:
-            print str(e)
-            self.error_code = -1
-        return self.press_enter_to_exit()
-
-    def exit_with(self, code):
-        """Exit the app with the specified error code."""
-        sys.exit(code)
-
-    def get_single_char_input(self, prompt, valid):
-        """Retrieve a single-character line from the input stream."""
-        valid = valid.upper()
-        input = None
-        while input is None:
-            input = self.input_method(prompt).upper()
-            if len(input) != 1 or input not in valid:
-                input = None
-        return input
-
-    def press_enter_to_exit(self):
-        """Make the user hit enter, and then exit with an error code."""
-        prompt = '\nPress enter to go back to "%s". ' % self.consumer_name
-        self.input_method(prompt)
-        self.exit_with(self.error_code)
-
-    def input_username(self, cached_username, suggested_message):
-        """Collect the Launchpad username from the end-user.
-
-        :param cached_username: A username from a previous entry attempt,
-        to be presented as the default.
-        """
-        if cached_username is not None:
-            extra = " [%s] " % cached_username
-        else:
-            extra = "\n(No Launchpad account? Just hit enter.) "
-        username = self.input_method(suggested_message + extra)
-        if username == '':
-            return cached_username
-        return username
-
-    def input_password(self, suggested_message):
-        """Collect the Launchpad password from the end-user."""
-        if self.input_method is raw_input:
-            password = getpass.getpass(suggested_message + " ")
-        else:
-            password = self.input_method(suggested_message)
-        return password
-
-    def input_access_level(self, available_levels, suggested_message,
-                           only_one_option=None):
-        """Collect the desired level of access from the end-user."""
-        if only_one_option is not None:
-            self.output(suggested_message)
-            prompt = self.message(
-                'Do you want to give "%(app)s" this level of access? [YN] ')
-            allow = self.get_single_char_input(prompt, "YN")
-            if allow == "Y":
-                return only_one_option['value']
-            else:
-                return self.UNAUTHORIZED_ACCESS_LEVEL
-        else:
-            levels_except_unauthorized = [
-                level for level in available_levels
-                if level['value'] != self.UNAUTHORIZED_ACCESS_LEVEL]
-            options = []
-            for i in range(0, len(levels_except_unauthorized)):
-                options.append(
-                    "%d: %s" % (i+1, levels_except_unauthorized[i]['title']))
-            self.output(suggested_message)
-            for option in options:
-                self.output(option)
-            allowed = ("".join(map(str, range(1, i+2)))) + "Q"
-            prompt = self.message(
-                'What should "%(app)s" be allowed to do using your '
-                'Launchpad account? [1-%(max)d or Q] ',
-                extra_variables = {'max' : i+1})
-            allow = self.get_single_char_input(prompt, allowed)
-            if allow == "Q":
-                return self.UNAUTHORIZED_ACCESS_LEVEL
-            else:
-                return levels_except_unauthorized[int(allow)-1]['value']
-
-    def user_refused_to_authorize(self, suggested_message):
-        """The user refused to authorize a request token."""
-        self.output(suggested_message)
-        self.error_code = -2
-
-    def user_authorized(self, access_level, suggested_message):
-        """The user authorized a request token with some access level."""
-        self.output(suggested_message)
-        self.error_code = 0
 
=== removed file 'src/launchpadlib/bin/launchpad-credentials-console'
--- src/launchpadlib/bin/launchpad-credentials-console	2009-10-30 17:28:51 +0000
+++ src/launchpadlib/bin/launchpad-credentials-console	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-#!/usr/bin/python
-
-# Copyright 2009 Canonical Ltd.
-
-# This file is part of launchpadlib.
-#
-# launchpadlib is free software: you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as published by the
-# Free Software Foundation, version 3 of the License.
-#
-# launchpadlib 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 Lesser General Public License
-# for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with launchpadlib. If not, see <http://www.gnu.org/licenses/>.
-
-"""Take the user's Launchpad credentials and authorize a request token.
-
-This script will guide the user through the process of authorizing a
-request token with their username and password. It's not as secure as
-opening the user's web browser, but if you are writing a console
-application and want to keep the authorization process console-based,
-it's better to use this script than write the authorization code yourself.
-"""
-
-__metaclass__ = type
-
-from optparse import OptionParser
-from launchpadlib.apps import (
-    RequestTokenApp, TrustedTokenAuthorizationConsoleApp)
-
-parser = OptionParser()
-parser.usage = "%prog CONSUMER_NAME REQUEST_TOKEN [-r URL] [-a LEVEL,LEVEL,...]"
-parser.add_option("-s", "--site", dest="web_root",
-                  help=("The name of the Launchpad site on which the request "
-                        "token can be found (default: %default). This can "
-                        "also be the URL to the root of the site."),
-                  metavar="URL", default="staging")
-parser.add_option("-a", "--access-level", dest="access_levels",
-                  help="Any restrictions on your clients' access levels",
-                  metavar="[LEVEL,LEVEL,...]", default="")
-
-if __name__ == '__main__':
-    (options, args) = parser.parse_args()
-    if len(args) < 2:
-        parser.error("You must provide both a consumer name and the ID of "
-                     "an OAuth request token on Launchpad.")
-    consumer_name, token_id = args[:2]
-    TrustedTokenAuthorizationConsoleApp(
-        options.web_root, consumer_name, token_id,
-        options.access_levels).run()
-
 
=== modified file 'src/launchpadlib/credentials.py'
--- src/launchpadlib/credentials.py	2010-07-19 21:47:03 +0000
+++ src/launchpadlib/credentials.py	2010-10-20 13:56:48 +0000
@@ -184,330 +184,23 @@
         super(AnonymousAccessToken, self).__init__('','')
 
 
-class SimulatedLaunchpadBrowser(object):
-    """A programmable substitute for a human-operated web browser.
-
-    Used by client programs to interact with Launchpad's credential
-    pages, without opening them in the user's actual web browser.
-    """
-
-    def __init__(self, web_root=uris.STAGING_WEB_ROOT):
-        self.web_root = uris.lookup_web_root(web_root)
-        self.http = httplib2.Http()
-
-    def _auth_header(self, username, password):
-        """Utility method to generate a Basic auth header."""
-        auth = base64.encodestring("%s:%s" % (username, password))[:-1]
-        return "Basic " + auth
-
-    def get_token_info(self, username, password, request_token,
-                       access_levels=''):
-        """Retrieve a JSON representation of a request token.
-
-        This is useful for verifying that the end-user gave a valid
-        username and password, and for reconciling the client's
-        allowable access levels with the access levels defined in
-        Launchpad.
-        """
-        if access_levels != '':
-            s = "&allow_permission="
-            access_levels = s + s.join(access_levels)
-        page = "%s?oauth_token=%s%s" % (
-            authorize_token_page, request_token, access_levels)
-        url = urljoin(self.web_root, page)
-        # We can't use httplib2's add_credentials, because Launchpad
-        # doesn't respond to credential-less access with a 401
-        # response code.
-        headers = {'Accept' : 'application/json',
-                   'Referer' : self.web_root}
-        headers['Authorization'] = self._auth_header(username, password)
-        response, content = self.http.request(url, headers=headers)
-        # Detect common error conditions and set the response code
-        # appropriately. This lets code that uses
-        # SimulatedLaunchpadBrowser detect standard response codes
-        # instead of having Launchpad-specific knowledge.
-        location = response.get('content-location')
-        if response.status == 200 and '+login' in location:
-            response.status = 401
-        elif response.get('content-type') != 'application/json':
-            response.status = 500
-        return response, content
-
-    def grant_access(self, username, password, request_token, access_level,
-                     context=None):
-        """Grant a level of access to an application on behalf of a user."""
-        headers = {'Content-type' : 'application/x-www-form-urlencoded',
-                   'Referer' : self.web_root}
-        headers['Authorization'] = self._auth_header(username, password)
-        body = "oauth_token=%s&field.actions.%s=True" % (
-            quote(request_token), quote(access_level))
-        if context is not None:
-            body += "&lp.context=%s" % quote(context)
-        url = urljoin(self.web_root, "+authorize-token")
-        response, content = self.http.request(
-            url, method="POST", headers=headers, body=body)
-        # This would be much less fragile if Launchpad gave us an
-        # error code to work with.
-        if "Unauthenticated user POSTing to page" in content:
-            response.status = 401 # Unauthorized
-        elif 'Request already reviewed' in content:
-            response.status = 409 # Conflict
-        elif 'What level of access' in content:
-            response.status = 400 # Bad Request
-        elif 'Unable to identify application' in content:
-            response.status = 400 # Bad Request
-        elif not 'Almost finished' in content:
-            response.status = 500 # Internal Server Error
-        return response, content
-
-
 class RequestTokenAuthorizationEngine(object):
 
     UNAUTHORIZED_ACCESS_LEVEL = "UNAUTHORIZED"
 
-    # Suggested messages for clients to display in common situations.
-
-    AUTHENTICATION_FAILURE = "I can't log in with the credentials you gave me. Let's try again."
-
-    CHOOSE_ACCESS_LEVEL = """Now it's time for you to decide how much power to give "%(app)s" over your Launchpad account."""
-
-    CHOOSE_ACCESS_LEVEL_ONE = CHOOSE_ACCESS_LEVEL + """
-
-"%(app)s" says it needs the following level of access to your Launchpad account: "%(level)s". It can't work with any other level of access, so denying this level of access means prohibiting "%(app)s" from using your Launchpad account at all."""
-
-    USER_AUTHORIZED = """Okay, I'm telling Launchpad to grant "%(app)s" access to your account."""
-
-    USER_REFUSED_TO_AUTHORIZE = """Okay, I'm going to cancel the request that "%(app)s" made for access to your account. You can always set this up again later."""
-
-    CLIENT_ERROR = """Sorry, but Launchpad is behaving in a way this client doesn't understand. There might be a bug in the client, a bug in the server, or this client might just be out of date."""
-
-    CONSUMER_MISMATCH = """WARNING: The application you're using told me its name was "%(old_consumer)s", but it told Launchpad its name was "%(real_consumer)s". This is probably not a problem, but it's a little suspicious, so you might want to look into this before continuing. I'll refer to the application as "%(real_consumer)s" from this point on."""
-
-    INPUT_USERNAME = "What email address do you use on Launchpad?"
-
-    INPUT_PASSWORD = "What's your Launchpad password? "
-
-    NONEXISTENT_REQUEST_TOKEN = """Launchpad couldn't find an outstanding request for integration between "%(app)s" and your Launchpad account. Either someone (hopefully you) already set up the integration, or else "%(app)s" is simply wrong and didn't actually set this up with Launchpad. If you still can't use "%(app)s" with Launchpad, try this process again from the beginning."""
-
-    REQUEST_TOKEN_ALREADY_AUTHORIZED = """It looks like you already approved this request to grant "%(app)s" access to your Launchpad account. You shouldn't need to do anything more."""
-
-    SERVER_ERROR = """There seems to be something wrong on the Launchpad server side, and I can't continue. Hopefully this is a temporary problem, but if it persists, it's probably because of a bug in Lauchpad or (less likely) a bug in "%(app)s"."""
-
-    STARTUP_MESSAGE = """An application identified as "%(app)s" wants to access Launchpad on your behalf. I'm the Launchpad credential client and I'm here to ask for your Launchpad username and password."""
-
-    STARTUP_MESSAGE_2 = """I'll use your Launchpad password to give "%(app)s" limited access to your Launchpad account. I will not show your password to "%(app)s" itself."""
-
-    SUCCESS = """You're all done! You should now be able to use Launchpad integration features of "%(app)s." """
-
-    SUCCESS_UNAUTHORIZED = """You're all done! "%(app)s" still doesn't have access to your Launchpad account."""
-
-    TOO_MANY_AUTHENTICATION_FAILURES = """You've failed the password entry too many times. I'm going to exit back to "%(app)s." Try again once you've solved the problem with your Launchpad account."""
-
-    YOU_NEED_A_LAUNCHPAD_ACCOUNT = """OK, you'll need to get yourself a Launchpad account before you can integrate Launchpad into "%(app)s."
-
-I'm opening the Launchpad registration page in your web browser so you can create an account. Once you've created an account, you can try this again."""
-
     def __init__(self, web_root, consumer_name, request_token,
-                 allow_access_levels=[], max_failed_attempts=3):
+                 allow_access_levels=[]):
         self.web_root = uris.lookup_web_root(web_root)
         self.consumer_name = consumer_name
         self.request_token = request_token
-        self.browser = SimulatedLaunchpadBrowser(self.web_root)
-        self.max_failed_attempts = max_failed_attempts
         self.allow_access_levels = allow_access_levels
-        self.text_wrapper = textwrap.TextWrapper(
-            replace_whitespace=False, width=78)
 
     def __call__(self):
-
-        self.startup(
-            [self.message(self.STARTUP_MESSAGE),
-             self.message(self.STARTUP_MESSAGE_2)])
-
-        # Have the end-user enter their Launchpad username and password.
-        # Make sure the credentials are valid, and get information
-        # about the request token as a side effect.
-        username, password, token_info = self.get_http_credentials()
-
-        # Update this object with fresh information about the request token.
-        self.token_info = token_info
-        self.reconciled_access_levels = token_info['access_levels']
-        self._check_consumer()
-
-        # Have the end-user choose an access level from the fresh list.
-        if len(self.reconciled_access_levels) == 2:
-            # There's only one choice: allow access at a certain level
-            # or don't allow access at all.
-            message = self.CHOOSE_ACCESS_LEVEL_ONE
-            level = [level for level in self.reconciled_access_levels
-                     if level['value'] != self.UNAUTHORIZED_ACCESS_LEVEL][0]
-            extra = {'level' : level['title']}
-            only_one_option = level
-        else:
-            message = self.CHOOSE_ACCESS_LEVEL
-            extra = None
-            only_one_option = None
-        access_level = self.input_access_level(
-            self.reconciled_access_levels, self.message(message, extra),
-            only_one_option)
-
-        # Notify the program of the user's choice.
-        if access_level == self.UNAUTHORIZED_ACCESS_LEVEL:
-            self.user_refused_to_authorize(
-                    self.message(self.USER_REFUSED_TO_AUTHORIZE))
-        else:
-            self.user_authorized(
-                access_level, self.message(self.USER_AUTHORIZED))
-
-        # Try to grant the specified level of access to the request token.
-        response, content = self.browser.grant_access(
-            username, password, self.request_token, access_level)
-        if response.status == 409:
-            raise RequestTokenAlreadyAuthorized(
-                self.message(self.REQUEST_TOKEN_ALREADY_AUTHORIZED))
-        elif response.status == 400:
-            raise ClientError(self.message(self.CLIENT_ERROR))
-        elif response.status == 500:
-            raise ServerError(self.message(self.SERVER_ERROR))
-        if access_level == self.UNAUTHORIZED_ACCESS_LEVEL:
-            message = self.SUCCESS_UNAUTHORIZED
-        else:
-            message = self.SUCCESS
-        self.success(self.message(message))
-
-    def get_http_credentials(self, cached_username=None, failed_attempts=0):
-        """Authenticate the user to Launchpad, or raise an exception trying.
-
-        :return: A 3-tuple (username, password,
-        token_info). 'username' and 'password' are the validated
-        Launchpad username and password. 'token_info' is a dict of
-        validated information about the request token, including
-        Launchpad's reconciled list of its available access levels
-        with the access levels the third-party client will accept.
-
-        :param cached_username: If the user has tried to enter their
-        credentials before and failed, this variable will contain the
-        username they entered the first time. This can be presented as
-        a default, since users are more likely to enter the wrong
-        password than the wrong username.
-
-        :param failed_attempts: This method calls itself recursively
-        until failed_attempts equals self.max_failed_attempts.
-        """
-        username = self.input_username(
-            cached_username, self.message(self.INPUT_USERNAME))
-        if username is None:
-            self.open_page_in_user_browser(
-                urljoin(self.web_root, "+login"))
-            raise NoLaunchpadAccount(
-                self.message(self.YOU_NEED_A_LAUNCHPAD_ACCOUNT))
-        password = self.input_password(self.message(self.INPUT_PASSWORD))
-        response, content = self.browser.get_token_info(
-            username, password, self.request_token, self.allow_access_levels)
-        if response.status == 500:
-            raise ServerError(self.message(self.SERVER_ERROR))
-        elif response.status == 401:
-            failed_attempts += 1
-            if failed_attempts == self.max_failed_attempts:
-                raise TooManyAuthenticationFailures(
-                    self.message(self.TOO_MANY_AUTHENTICATION_FAILURES))
-            else:
-                self.authentication_failure(
-                    self.message(self.AUTHENTICATION_FAILURE))
-                return self.get_http_credentials(username, failed_attempts)
-        token_info = simplejson.loads(content)
-        # If Launchpad provides no information about the request token,
-        # that means the request token doesn't exist.
-        if 'oauth_token' not in token_info:
-            raise RequestTokenAlreadyAuthorized(
-                self.message(self.NONEXISTENT_REQUEST_TOKEN))
-        return username, password, token_info
-
-    def _check_consumer(self):
-        """Sanity-check the server consumer against the client consumer."""
-        real_consumer = self.token_info['oauth_token_consumer']
-        if real_consumer != self.consumer_name:
-            message = self.message(
-                self.CONSUMER_MISMATCH, { 'old_consumer' : self.consumer_name,
-                                          'real_consumer' : real_consumer })
-            self.server_consumer_differs_from_client_consumer(
-                self.consumer_name, real_consumer, message)
-            self.consumer_name = real_consumer
-
-    def message(self, raw_message, extra_variables=None):
-        """Prepare a message by plugging in the app name."""
-        variables = { 'app' : self.consumer_name }
-        if extra_variables is not None:
-            variables.update(extra_variables)
-        return raw_message % variables
-
-    def open_page_in_user_browser(self, url):
-        """Open a web page in the user's web browser."""
-        webbrowser.open(url)
-
-    # You should define these methods in your subclass.
-
-    def output(self, message):
-        print self.text_wrapper.fill(message)
-
-    def input_username(self, cached_username, suggested_message):
-        """Collect the Launchpad username from the end-user.
-
-        :param cached_username: A username from a previous entry attempt,
-        to be presented as the default.
-        """
-        raise NotImplementedError()
-
-    def input_password(self, suggested_message):
-        """Collect the Launchpad password from the end-user."""
-        raise NotImplementedError()
-
-    def input_access_level(self, available_levels, suggested_message,
-                           only_one_option=None):
-        """Collect the desired level of access from the end-user."""
-        raise NotImplementedError()
-
-    def startup(self, suggested_messages):
-        """Hook method called on startup."""
-        for message in suggested_messages:
-            self.output(message)
-            self.output("\n")
-
-    def authentication_failure(self, suggested_message):
-        """The user entered invalid credentials."""
-        self.output(suggested_message)
-        self.output("\n")
-
-    def user_refused_to_authorize(self, suggested_message):
-        """The user refused to authorize a request token."""
-        self.output(suggested_message)
-        self.output("\n")
-
-    def user_authorized(self, access_level, suggested_message):
-        """The user authorized a request token with some access level."""
-        self.output(suggested_message)
-        self.output("\n")
-
-    def server_consumer_differs_from_client_consumer(
-        self, client_name, real_name, suggested_message):
-        """The client seems to be lying or mistaken about its name.
-
-        When requesting a request token, the client told Launchpad
-        that its consumer name was "foo". Now the client is telling the
-        end-user that its name is "bar". Something is fishy and at the very
-        least the end-user should be warned about this.
-        """
-        self.output("\n")
-        self.output(suggested_message)
-        self.output("\n")
-
-    def success(self, suggested_message):
-        """The token was successfully authorized."""
-        self.output(suggested_message)
+        raise NotImplementedError()
 
 
 class AuthorizeRequestTokenWithBrowser(RequestTokenAuthorizationEngine):
-    """The simplest and most secure request token authorizer.
+    """The simplest (and, right now, only) request token authorizer.
 
     This authorizer simply opens up the end-user's web browser to a
     Launchpad URL and lets the end-user authorize the request token
 
=== removed file 'src/launchpadlib/docs/browser.txt'
--- src/launchpadlib/docs/browser.txt	2009-10-28 18:04:29 +0000
+++ src/launchpadlib/docs/browser.txt	1970-01-01 00:00:00 +0000
@@ -1,151 +0,0 @@
-*******************************
-The simulated Launchpad browser
-*******************************
-
-The SimulatedLaunchpadBrowser class is a scriptable browser-like class
-that can be trusted with the end-user's username and password. It
-fulfils the same function as the user's web browser, but because it's
-scriptable can be used to create non-browser trusted clients.
-
-    >>> username = '[e-mail]'
-    >>> password = 'zeca'
-    >>> web_root = 'http://launchpad.dev:8085/'
-
-Before showing how SimulatedLaunchpadBrowser can authorize a request
-token, let's create a request token to authorize.
-
-    >>> from launchpadlib.credentials import Credentials
-    >>> credentials = Credentials("doctest consumer")
-    >>> context="firefox"
-    >>> validate_url = credentials.get_request_token(
-    ...     web_root=web_root, context=context)
-    >>> request_token = credentials._request_token.key
-
-get_token_info()
-================
-
-If you have the end-user's username and password, you can use
-get_token_info() to get information about one of the user's request
-tokens. It's useful for confirming that the end-user gave the correct
-username and password, and for reconciling the list of access levels a
-client will accept with Launchpad's master list.
-
-    >>> from launchpadlib.credentials import SimulatedLaunchpadBrowser
-    >>> from launchpadlib.testing.helpers import TestableLaunchpad
-
-    >>> browser = SimulatedLaunchpadBrowser(web_root)
-
-If you make an unauthorized request, you'll get a 401 error.
-(Launchpad returns 200, but SimulatedLaunchpadBrowser sniffs it and
-changes it to a 401.)
-
-    >>> response, content = browser.get_token_info(
-    ...     "baduser", "badpasword", request_token)
-    >>> print response.status
-    401
-
-If you provide the right authorization, you'll get back information
-about your request token.
-
-    >>> response, content = browser.get_token_info(
-    ...     username, password, request_token)
-    >>> print response['content-type']
-    application/json
-
-    # XXX leonardr 2009-10-28 bug=462773 These two URLs should be
-    # exactly the same, but the Content-Location is missing the
-    # lp.context.
-    >>> validate_url.startswith(response['content-location'])
-    True
-
-    >>> import simplejson
-    >>> json = simplejson.loads(content)
-    >>> json['oauth_token'] == request_token
-    True
-
-    >>> print json['oauth_token_consumer']
-    doctest consumer
-
-You'll also get information about the available access
-levels.
-
-    >>> print sorted([level['value'] for level in json['access_levels']])
-    ['READ_PRIVATE', ... 'UNAUTHORIZED', ...]
-
-If you provide a list of possible access levels, you'll
-get back a list that reconciles the list you gave with
-Launchpad's access levels.
-
-    >>> response, content = browser.get_token_info(
-    ...     username, password, request_token,
-    ...     ["READ_PUBLIC", "READ_PRIVATE", "NO_SUCH_ACCESS_LEVEL"])
-
-    >>> print response['content-type']
-    application/json
-
-    >>> json = simplejson.loads(content)
-    >>> print sorted(
-    ...     [level['value'] for level in json['access_levels']])
-    ['READ_PRIVATE', 'READ_PUBLIC', 'UNAUTHORIZED']
-
-Note that the nonexistent access level has been removed from the
-reconciled list, and the "Unauthorized" access level (which must
-always be an option) has been added.
-
-grant_access()
-==============
-
-If you have the end-user's username and password, you can use
-grant_access() to authorize a request token.
-
-If you make an unauthorized request, you'll get a 401 error.  (As with
-get_token_info(), Launchpad returns 200, but SimulatedLaunchpadBrowser
-sniffs it and changes it to a 401.)
-
-    >>> access_level = "READ_PRIVATE"
-
-    >>> response, content = browser.grant_access(
-    ...     "baduser", "badpasword", request_token, access_level, context)
-    >>> print response.status
-    401
-
-If you try to grant an invalid level of access, you'll get a
-400 error.
-
-    >>> response, content = browser.grant_access(
-    ...     username, password, request_token,
-    ...     "NO_SUCH_ACCESS_LEVEL")
-    >>> print response.status
-    400
-
-If you provide all the necessary information, you'll get a 200
-response code and the request token will be authorized.
-
-    >>> response, content = browser.grant_access(
-    ...     username, password, request_token, access_level)
-    >>> print response.status
-    200
-
-If you try to grant access to a request token that's already
-been authorized, you'll get a 409 error.
-
-    >>> response, content = browser.grant_access(
-    ...     username, password, request_token, access_level)
-    >>> print response.status
-    409
-
-Now that the request token is authorized, we can exchange it for an
-access token.
-
-    >>> credentials.exchange_request_token_for_access_token(
-    ...     web_root=web_root)
-    >>> credentials.access_token.key is None
-    False
-
-If you try to grant access to a request token that's already been
-exchanged for an access token, you'll get a 400 error.
-
-    >>> response, content = browser.grant_access(
-    ...     username, password, request_token, access_level)
-    >>> print response.status
-    400
 
=== modified file 'src/launchpadlib/docs/command-line.txt'
--- src/launchpadlib/docs/command-line.txt	2009-11-03 13:50:27 +0000
+++ src/launchpadlib/docs/command-line.txt	2010-10-20 13:56:48 +0000
@@ -2,12 +2,11 @@
 Command-line scripts
 ********************
 
-Launchpad includes some command-line scripts to make Launchpad
+Launchpad includes one command-line script to make Launchpad
 integration easier for third-party libraries that aren't written in
-Python or that can't do token authorization by opening a user's web
-browser.
+Python.
 
-This file tests the workflow underlying the command-line scripts as
+This file tests the workflow underlying the command-line script as
 best it can.
 
 RequestTokenApp
@@ -36,170 +35,3 @@
     >>> print json['oauth_token_consumer']
     consumer
 
-TrustedTokenAuthorizationConsoleApp
-===================================
-
-This class is called by the command-line script
-launchpad-credentials-console. It asks for the user's Launchpad
-username and password, and authorizes a request token on their
-behalf.
-
-    >>> from launchpadlib.apps import TrustedTokenAuthorizationConsoleApp
-    >>> from launchpadlib.testing.helpers import UserInput
-
-This class does not create the request token, or exchange it for the
-access token--that's the job of the program that calls
-launchpad-credentials-console. So we'll use the request token created
-earlier by RequestTokenApp.
-
-    >>> request_token = json['oauth_token']
-
-Since this is a test, we don't want the application to call sys.exit()
-or try to open up pages in a web browser. This subclass of
-TrustedTokenAuthorizationConsoleApp will print messages instead of
-performing such un-doctest-like actions.
-
-    >>> class ConsoleApp(TrustedTokenAuthorizationConsoleApp):
-    ...     def open_page_in_user_browser(self, url):
-    ...         """Print a status message."""
-    ...         self.output("[If this were a real application, the "
-    ...                     "end-user's web browser would be opened "
-    ...                     "to %s]" % url)
-    ...
-    ...     def exit_with(self, code):
-    ...         print "Application exited with code %d" % code
-
-We'll use a UserInput object to simulate a user typing things in at
-the prompt and hitting enter. This UserInput runs the program
-correctly, entering the Launchpad username and password, choosing an
-access level, and hitting Enter to exit.
-
-    >>> username = "[e-mail]"
-    >>> password = "zeca"
-    >>> fake_input = UserInput([username, password, "1", ""])
-
-Here's a successful run of the application. When the request token is
-authorized, the script's response code is 0.
-
-    >>> app = ConsoleApp(
-    ...     web_root, consumer_name, request_token,
-    ...     'READ_PRIVATE, READ_PUBLIC', input_method=fake_input)
-    >>> app.run()
-    Launchpad credential client (console)
-    -------------------------------------
-    An application identified as "consumer" wants to access Launchpad...
-    What email address do you use on Launchpad?
-    (No Launchpad account? Just hit enter.) [User input: [e-mail]]
-    What's your Launchpad password? [User input: zeca]
-    Now it's time for you to decide how much power to give "consumer"...
-    1: Read Non-Private Data
-    2: Read Anything
-    What should "consumer" be allowed to do...? [1-2 or Q] [User input: 1]
-    Okay, I'm telling Launchpad to grant "consumer" access to your account.
-    You're all done!...
-    Press enter to go back to "consumer". [User input: ]
-    Application exited with code 0
-
-Now that the request token has been authorized, we'll need to create
-another one to continue the test.
-
-    >>> json = simplejson.loads(token_app.run())
-    >>> request_token = json['oauth_token']
-    >>> app.request_token = request_token
-
-Invalid input is ignored. The user may enter 'Q' instead of a number
-to refuse to authorize the request token. When the user denies access,
-the exit code is -2.
-
-    >>> fake_input = UserInput([username, password, "A", "99", "Q", ""])
-    >>> app.input_method = fake_input
-    >>> app.run()
-    Launchpad credential client (console)
-    -------------------------------------
-    An application identified as "consumer"...
-    What should "consumer" be allowed to do...? [1-2 or Q] [User input: A]
-    What should "consumer" be allowed to do...? [1-2 or Q] [User input: 99]
-    What should "consumer" be allowed to do...? [1-2 or Q] [User input: Q]
-    Okay, I'm going to cancel the request...
-    You're all done! "consumer" still doesn't have access...
-    <BLANKLINE>
-    Press enter to go back to "consumer". [User input: ]
-    Application exited with code -2
-
-When the third-party application will allow only one level of access,
-the end-user is presented with a yes-or-no choice instead of a list to
-choose from. Again, invalid input is ignored.
-
-    >>> json = simplejson.loads(token_app.run())
-    >>> request_token = json['oauth_token']
-    >>> fake_input = UserInput([username, password, "1", "Q", "Y", ""])
-
-    >>> app = ConsoleApp(
-    ...     web_root, consumer_name, request_token,
-    ...     'READ_PRIVATE', input_method=fake_input)
-
-    >>> app.run()
-    Launchpad credential client (console)
-    -------------------------------------
-    An application identified as "consumer"...
-    Do you want to give "consumer" this level of access? [YN] [User input: 1]
-    Do you want to give "consumer" this level of access? [YN] [User input: Q]
-    Do you want to give "consumer" this level of access? [YN] [User input: Y]
-    ...
-    Application exited with code 0
-
-
-Error handling
---------------
-
-When the end-user refuses to authorize the request token, the app
-exits with a return code of -2, as seen above. When any other error
-gets in the way of the authorization of the request token, the app's
-return code is -1.
-
-If the user hits enter when asked for their email address, indicating
-that they don't have a Launchpad account, the app opens their browser
-to the Launchpad login page.
-
-    >>> json = simplejson.loads(token_app.run())
-    >>> app.request_token = json['oauth_token']
-
-    >>> input_nothing = UserInput(["", ""])
-    >>> app.input_method = input_nothing
-
-    >>> app.run()
-    Launchpad credential client (console)
-    -------------------------------------
-    An application identified as "consumer"...
-    [If this were a real application, the end-user's web browser...]
-    OK, you'll need to get yourself a Launchpad account before...
-    <BLANKLINE>
-    I'm opening the Launchpad registration page in your web browser...
-    Press enter to go back to "consumer". [User input: ]
-    Application exited with code -1
-
-If the user keeps entering bad passwords, the app eventually gives up.
-
-    >>> input_bad_password = UserInput(
-    ...     [username, "badpw", "", "badpw", "", "badpw", ""])
-    >>> json = simplejson.loads(token_app.run())
-    >>> request_token = json['oauth_token']
-    >>> app.request_token = request_token
-    >>> app.input_method = input_bad_password
-    >>> app.run()
-    Launchpad credential client (console)
-    -------------------------------------
-    An application identified as "consumer"...
-    What email address do you use on Launchpad?
-    (No Launchpad account? Just hit enter.)  [User input: [e-mail]]
-    What's your Launchpad password? [User input: badpw]
-    I can't log in with the credentials you gave me. Let's try again.
-    What email address do you use on Launchpad? [[e-mail]] [User input: ]
-    What's your Launchpad password? [User input: badpw]
-    I can't log in with the credentials you gave me. Let's try again.
-    What email address do you use on Launchpad? [[e-mail]] [User input: ]
-    What's your Launchpad password? [User input: badpw]
-    You've failed the password entry too many times...
-    Press enter to go back to "consumer". [User input: ]
-    Application exited with code -1
-
 
=== modified file 'src/launchpadlib/docs/introduction.txt'
--- src/launchpadlib/docs/introduction.txt	2010-08-17 20:21:12 +0000
+++ src/launchpadlib/docs/introduction.txt	2010-10-20 13:56:48 +0000
@@ -211,12 +211,12 @@
     salgado
 
 Otherwise, the application should obtain authorization from the user
-and get a new set of credentials directly from Launchpad.
+and get a new set of credentials directly from
+Launchpad.
 
-First we must get a request token. We use 'test_dev' as a shorthand
-for the root URL of the Launchpad installation. It's defined in the
-'uris' module as 'http://launchpad.dev:8085/', and the launchpadlib
-code knows how to dereference it before using it as a URL.
+Unfortunately, we can't test this entire process because it requires
+opening up a web browser, but we can test the first step, which is to
+get a request token.
 
     >>> import launchpadlib.credentials
     >>> credentials = Credentials('consumer')
@@ -226,6 +226,11 @@
     >>> authorization_url
     'http://launchpad.dev:8085/+authorize-token?oauth_token=...&lp.context=firefox'
 
+We use 'test_dev' as a shorthand for the root URL of the Launchpad
+installation. It's defined in the 'uris' module as
+'http://launchpad.dev:8085/', and the launchpadlib code knows how to
+dereference it before using it as a URL.
+
 Information about the request token is kept in the _request_token
 attribute of the Credentials object.
 
@@ -236,121 +241,10 @@
     >>> print credentials._request_token.context
     firefox
 
-Now the user must authorize that token, so we'll use the
-SimulatedLaunchpadBrowser to pretend the user is authorizing it.
-
-    >>> from launchpadlib.credentials import SimulatedLaunchpadBrowser
-    >>> browser = SimulatedLaunchpadBrowser(web_root='test_dev')
-    >>> response, content = browser.grant_access(
-    ...     "[e-mail]", "test",
-    ...     credentials._request_token.key, "WRITE_PRIVATE",
-    ...     credentials._request_token.context)
-    >>> response['status']
-    '200'
-
-After that we can exchange that request token for an access token.
-
-    >>> credentials.exchange_request_token_for_access_token(
-    ...     web_root='test_dev')
-
-Once that's done, our credentials will be complete and ready to use.
-
-    >>> credentials.consumer.key
-    'consumer'
-    >>> credentials.access_token
-    <launchpadlib.credentials.AccessToken...
-    >>> credentials.access_token.key is not None
-    True
-    >>> credentials.access_token.secret is not None
-    True
-    >>> credentials.access_token.context
-    'firefox'
-
-# [XXX leonardr 2010-08-17 bug=619446] Commenting out tests that
-# started failing due to assuming Launchpad behavior that no longer
-# exists.
-
-# Authorizing the request token
-# -----------------------------
-
-# There are also two convenience method which do the access token
-# negotiation and log into the web service: get_token_and_login() and
-# login_with(). These convenience methods use the methods documented
-# above to get a request token, and once it has the request token's
-# authorization information, it makes the end-user authorize the request
-# token by entering their Launchpad username and password.
-
-# There are several ways of having the end-user authorize a request
-# token, but the most secure is to open up the user's own web browser
-# (other ways are described in trusted-client.txt). Because we don't
-# want to actually open a web browser during this test, we'll create a
-# fake authorizer that uses the SimulatedLaunchpadBrowser to authorize
-# the request token.
-
-#     >>> from launchpadlib.testing.helpers import (
-#     ...     DummyAuthorizeRequestTokenWithBrowser)
-
-#     >>> class AuthorizeAsSalgado(DummyAuthorizeRequestTokenWithBrowser):
-#     ...     def wait_for_request_token_authorization(self):
-#     ...         """Simulate the authorizing user with their web browser."""
-#     ...         username = '[e-mail]'
-#     ...         password = 'zeca'
-#     ...         browser = SimulatedLaunchpadBrowser(self.web_root)
-#     ...         browser.grant_access(username, password, self.request_token,
-#     ...                              'READ_PUBLIC')
-
-# Here, we're using 'test_dev' as shorthand for the root URL of the web
-# service. Earlier we used 'test_dev' as shorthand for the website URL,
-# and like in that earlier case, launchpadlib will internally
-# dereference 'test_dev' into the service root URL, defined in the
-# 'uris' module as "http://api.launchpad.dev:8085/".
-
-#     >>> consumer_name = 'launchpadlib'
-#     >>> launchpad = Launchpad.get_token_and_login(
-#     ...     consumer_name, service_root="test_dev",
-#     ...     authorizer_class=AuthorizeAsSalgado)
-#     [If this were a real application, the end-user's web browser would
-#     be opened to http://launchpad.dev:8085/+authorize-token?oauth_token=...]
-#     The authorization page:
-#     (http://launchpad.dev:8085/+authorize-token?oauth_token=...)
-#     should be opening in your browser. After you have authorized
-#     this program to access Launchpad on your behalf you should come
-#     back here and press <Enter> to finish the authentication process.
-
-# The login_with method will cache an access token once it gets one, so
-# that the end-user doesn't have to authorize a request token every time
-# they run the program.
-
-#     >>> import tempfile
-#     >>> cache_dir = tempfile.mkdtemp()
-#     >>> launchpad = Launchpad.login_with(
-#     ...     consumer_name, service_root="test_dev",
-#     ...     launchpadlib_dir=cache_dir,
-#     ...     authorizer_class=AuthorizeAsSalgado)
-#     [If this were a real application...]
-#     The authorization page:
-#     ...
-#     >>> print launchpad.me.name
-#     salgado
-
-# Now that the access token is authorized, we can call login_with()
-# again and pass in a null authorizer. If there was no access token,
-# this would fail, because there would be no way to authorize the
-# request token. But since there's an access token cached in the
-# cache directory, login_with() will succeed without even trying to
-# authorize a request token.
-
-#     >>> launchpad = Launchpad.login_with(
-#     ...     consumer_name, service_root="test_dev",
-#     ...     launchpadlib_dir=cache_dir,
-#     ...     authorizer_class=None)
-#     >>> print launchpad.me.name
-#     salgado
-
-# A bit of clean-up: removing the cache directory.
-
-#     >>> import shutil
-#     >>> shutil.rmtree(cache_dir)
+Now the user must authorize that token, and this is the part we can't
+test--it requires opening a web browser. Once the token is authorized
+on the server side, we can call exchange_request_token_for_access_token()
+on our Credentials object, which will then be ready to use.
 
 The dictionary request token
 ============================
 
=== removed file 'src/launchpadlib/docs/trusted-client.txt'
--- src/launchpadlib/docs/trusted-client.txt	2009-10-30 19:19:07 +0000
+++ src/launchpadlib/docs/trusted-client.txt	1970-01-01 00:00:00 +0000
@@ -1,224 +0,0 @@
-***********************
-Making a trusted client
-***********************
-
-To authorize a request token, the end-user must type in their
-Launchpad username and password. Obviously, typing your password into
-a random program is a bad idea. The best case is to use a program you
-already trust with your Launchpad password: your web browser.
-
-But if you're writing an application that can't open the end-user's
-web browser, or you just really want a token authorization client that
-has the same UI as the rest of your application, you should use one of
-the trusted clients packaged with launchpadlib, rather than writing
-your own client.
-
-All the trusted clients are based on the same core code and implement
-the same workflow. This test implements a scriptable trusted client
-and uses it to test the behavior of the standard workflow.
-
-    >>> from launchpadlib.testing.helpers import (
-    ...     ScriptableRequestTokenAuthorization)
-
-Here we see the normal workflow, in which the user inputs all the
-correct data to authorize a request token.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "[e-mail]", "zeca",
-    ...     "WRITE_PRIVATE",
-    ...     allow_access_levels = ["WRITE_PUBLIC", "WRITE_PRIVATE"])
-    >>> access_token = auth()
-    An application identified as "consumer" wants to access Launchpad...
-    <BLANKLINE>
-    I'll use your Launchpad password to give "consumer" limited access...
-    What email address do you use on Launchpad?
-    What's your Launchpad password?
-    Now it's time for you to decide how much power to give "consumer" ...
-    ['UNAUTHORIZED', 'WRITE_PUBLIC', 'WRITE_PRIVATE']
-    Okay, I'm telling Launchpad to grant "consumer" access to your account.
-    You're all done! You should now be able to use Launchpad ...
-
-Ordinarily, the third-party program will create a request token and
-pass it into the trusted client. The test class is a little unusual:
-it takes care of creating the request token and, after the end-user
-has authorized it, exchanges the request token for an access
-token. This way we can verify that the entire end-to-end process
-works.
-
-    >>> access_token.key is not None
-    True
-
-Denying access
-==============
-
-It's always possible for the end-user to deny access to the
-application. This will make it impossible to convert the request token
-into an access token.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "[e-mail]", "zeca", "UNAUTHORIZED")
-    >>> access_token = auth()
-    An application identified as "consumer" wants to access Launchpad...
-    What email address do you use on Launchpad?
-    ...
-    Okay, I'm going to cancel the request that "consumer" made...
-    You're all done! "consumer" still doesn't have access...
-
-    >>> access_token is None
-    True
-
-Only one allowable access level
-===============================
-
-When the application being authenticated only allows one access level,
-the authorizer creates a special message for display to the end-user.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "[e-mail]", "zeca",
-    ...     "WRITE_PRIVATE", allow_access_levels=["WRITE_PRIVATE"])
-
-    >>> auth()
-    An application identified as "consumer" wants to access Launchpad ...
-    ...
-    "consumer" says it needs the following level of access to your Launchpad
-    account: "Change Anything". It can't work with any other level of access,
-    so denying this level of access means prohibiting "consumer" from
-    using your Launchpad account at all.
-    ...
-
-Error handling
-==============
-
-Things can go wrong in many ways, most of which we can test with our
-scriptable authorizer. Here's a utility method to run the
-authorization process with a badly-scripted authorizer and print the
-resulting exception.
-
-    >>> from launchpadlib.credentials import TokenAuthorizationException
-    >>> def print_error(auth):
-    ...     try:
-    ...         auth()
-    ...     except TokenAuthorizationException, e:
-    ...         print str(e)
-
-Authentication failures
------------------------
-
-If the user doesn't have a Launchpad account, or refuses to type in
-their email address, the authorizer will open their web browser to the
-login page, and raise an exception.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", None, "zeca", "WRITE_PRIVATE")
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad ...
-    [If this were a real application, ... opened to http://launchpad.dev:8085/+login]
-    OK, you'll need to get yourself a Launchpad account before you can ...
-    <BLANKLINE>
-    I'm opening the Launchpad registration page in your web browser ...
-
-If the user enters the wrong username/password combination too many
-times, the authorizer will give up and raise an exception.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "[e-mail]", "baddpassword",
-    ...     "WRITE_PRIVATE")
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad...
-    ...
-    What email address do you use on Launchpad?
-    What's your Launchpad password?
-    I can't log in with the credentials you gave me. Let's try again.
-    What email address do you use on Launchpad?
-    Cached email address: [e-mail]
-    What's your Launchpad password?
-    You've failed the password entry too many times...
-
-The max_failed_attempts argument controls how many attempts the user
-is given to enter their username and password.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "bad username", "zeca",
-    ...     "WRITE_PRIVATE", max_failed_attempts=1)
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad ...
-    What email address do you use on Launchpad?
-    What's your Launchpad password?
-    You've failed the password entry too many times...
-
-Approving a token that was already approved
--------------------------------------------
-
-To set this up, let's approve a request token but not exchange it for
-an access token.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "[e-mail]", "zeca",
-    ...     "WRITE_PRIVATE")
-    >>> auth(exchange_for_access_token=False)
-    An application identified as "consumer" wants to access Launchpad ...
-    ...
-
-Now let's try to approve the request token again:
-
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad ...
-    ...
-    It looks like you already approved this request...
-
-Once the request token is exchanged for an access token, it's
-deleted. An attempt to approve a request token that's already been
-exchanged for an access token gives an error message.
-
-    >>> auth.credentials.exchange_request_token_for_access_token(
-    ...     web_root=auth.web_root)
-
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad ...
-    ...
-    Launchpad couldn't find an outstanding request for integration...
-
-An attempt to approve a nonexistent request token gives the same error
-message.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer", "[e-mail]", "zeca",
-    ...     "WRITE_PRIVATE")
-    >>> auth.request_token = "nosuchrequesttoken"
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad ...
-    ...
-    Launchpad couldn't find an outstanding request for integration...
-
-Miscellaneous error
--------------------
-
-Random errors on the server side or (occasionally) the client side
-will result in a generic error message.
-
-    >>> auth.request_token = "this token will confuse launchpad badly"
-    >>> print_error(auth)
-    An application identified as "consumer" wants to access Launchpad ...
-    ...
-    There seems to be something wrong on the Launchpad server side...
-
-Client duplicity
-----------------
-
-If the third-party client gives one consumer name to Launchpad, and a
-different consumer name to the authorizer, the authorizer will detect
-this possible duplicity and print a warning.
-
-    >>> auth = ScriptableRequestTokenAuthorization(
-    ...     "consumer1", "[e-mail]", "zeca",
-    ...     "WRITE_PRIVATE")
-
-We'll simulate this by changing the authorizer's .consumer_name after
-it obtained a request token from Launchpad.
-
-    >>> auth.consumer_name = "consumer2"
-    >>> auth()
-    An application identified as "consumer2" wants to access Launchpad ...
-    ...
-    WARNING: The application you're using told me its name was "consumer2", but it told Launchpad its name was "consumer1"...
-    ...
 
=== modified file 'src/launchpadlib/testing/helpers.py'
--- src/launchpadlib/testing/helpers.py	2010-02-15 16:34:26 +0000
+++ src/launchpadlib/testing/helpers.py	2010-10-20 13:56:48 +0000
@@ -31,8 +31,9 @@
 
 from launchpadlib.launchpad import Launchpad
 from launchpadlib.credentials import (
-    AuthorizeRequestTokenWithBrowser, Credentials,
-    RequestTokenAuthorizationEngine, SimulatedLaunchpadBrowser)
+    AuthorizeRequestTokenWithBrowser,
+    Credentials,
+    )
 
 
 class TestableLaunchpad(Launchpad):
@@ -65,106 +66,3 @@
 salgado_with_full_permissions = KnownTokens('salgado-change-anything', 'test')
 salgado_read_nonprivate = KnownTokens('salgado-read-nonprivate', 'secret')
 nopriv_read_nonprivate = KnownTokens('nopriv-read-nonprivate', 'mystery')
-
-
-class ScriptableRequestTokenAuthorization(RequestTokenAuthorizationEngine):
-    """A request token process that doesn't need any user input.
-
-    The RequestTokenAuthorizationEngine is supposed to be hooked up to a
-    user interface, but that makes it difficult to test. This subclass
-    is designed to be easy to test.
-    """
-
-    def __init__(self, consumer_name, username, password, choose_access_level,
-                 allow_access_levels=[], max_failed_attempts=2,
-                 web_root="http://launchpad.dev:8085/"):
-
-        # Get a request token.
-        self.credentials = Credentials(consumer_name)
-        self.credentials.get_request_token(web_root=web_root)
-
-        # Initialize the superclass with the new request token.
-        super(ScriptableRequestTokenAuthorization, self).__init__(
-            web_root, consumer_name, self.credentials._request_token.key,
-                allow_access_levels, max_failed_attempts)
-
-        self.username = username
-        self.password = password
-        self.choose_access_level = choose_access_level
-
-    def __call__(self, exchange_for_access_token=True):
-        super(ScriptableRequestTokenAuthorization, self).__call__()
-
-        # Now verify that it worked by exchanging the authorized
-        # request token for an access token.
-        if (exchange_for_access_token and
-            self.choose_access_level != self.UNAUTHORIZED_ACCESS_LEVEL):
-            self.credentials.exchange_request_token_for_access_token(
-                web_root=self.web_root)
-            return self.credentials.access_token
-        return None
-
-    def open_page_in_user_browser(self, url):
-        """Print a status message."""
-        print ("[If this were a real application, the end-user's web "
-               "browser would be opened to %s]" % url)
-
-    def input_username(self, cached_username, suggested_message):
-        """Collect the Launchpad username from the end-user."""
-        print suggested_message
-        if cached_username is not None:
-            print "Cached email address: " + cached_username
-        return self.username
-
-    def input_password(self, suggested_message):
-        """Collect the Launchpad password from the end-user."""
-        print suggested_message
-        return self.password
-
-    def input_access_level(self, available_levels, suggested_message,
-                           only_one_option):
-        """Collect the desired level of access from the end-user."""
-        print suggested_message
-        print [level['value'] for level in available_levels]
-        return self.choose_access_level
-
-    def startup(self, suggested_messages):
-        for message in suggested_messages:
-            print message
-
-
-class DummyAuthorizeRequestTokenWithBrowser(AuthorizeRequestTokenWithBrowser):
-
-    def __init__(self, web_root, consumer_name, request_token, username,
-                 password, allow_access_levels=[], max_failed_attempts=3):
-        super(DummyAuthorizeRequestTokenWithBrowser, self).__init__(
-            web_root, consumer_name, request_token, allow_access_levels,
-            max_failed_attempts)
-
-    def open_page_in_user_browser(self, url):
-        """Print a status message."""
-        print ("[If this were a real application, the end-user's web "
-               "browser would be opened to %s]" % url)
-
-
-class UserInput(object):
-    """A class to store fake user input in a readable way.
-
-    An instance of this class can be used as a substitute for the
-    raw_input() function.
-    """
-
-    def __init__(self, inputs):
-        """Initialize with a line of user inputs."""
-        self.stream = iter(inputs)
-
-    def __call__(self, prompt):
-        """Print and return the next line of input."""
-        line = self.readline()
-        print prompt + "[User input: %s]" % line
-        return line
-
-    def readline(self):
-        """Return the next line of input."""
-        next_input = self.stream.next()
-        return str(next_input)