Merge ~woutervb/snapstore-client:SN-399_use_click into snapstore-client:master

[Wouter van Bommel]

CLI options moved to click / blackified

* Converted the project to a standard setuptools one
* Updated to snapcraft.yaml to make use of this
* Fixed a bug in the Makefile, preventing the creation of a snap
* Moved all commandline parsing and log handling to click & click_logging
* Updated called methods to reflex this change
* Reworked test to handle new logger

Fixes SN-399

Depends on updates to ols-goodyear https://code.launchpad.net/~woutervb/ols-goodyear/+git/sdists/+merge/414339

[Przemysław Suliga (suligap)]

As we discussed in a call, I think we should first create a design doc for this essentially new tool -- snap name changed here and we have the opportunity to design a new command tree layout for example.

In the design I think we should agree on:

* The split between commands for managing online proxy and offline store.
* Command names/options.
* Snap name itself.
* The root command name.
* How to make it authority delegation future proof.
* The login command currently handles login to the online proxy only for the purposes of managing overrides. The login action itself also needs internet access. Should it be only available under the "online" subcommand tree.

[Maximiliano Bertacchini (maxiberta)]

May I suggest to move all black+formatting into a separate MP for easier reviewing? Preferrably with a first commit adding tools, black, deps, etc. then a commit with the results of a fully automated black run, then a commit with manual formatting fixes, and so on? Thanks!

Unmerged commits

168e30e... by Wouter van Bommel on 2022-01-19

Reworked the unittest to use TestCase assertLog

Reformatted all with black for consistency, added black to Makefile &
requirements

641d0d2... by Wouter van Bommel on 2022-01-18

CLI options moved to click

* Converted the project to a standard setuptools one
* Updated to snapcraft.yaml to make use of this
* Fixed a bug in the Makefile, preventing the creation of a snap
* Moved all commandline parsing and log handling to click & click_logging
* Updated called methods to reflex this change

Fixes SN-399

diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..e0ea542
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 88
+extend-ignore = E203
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 4fc1b77..fa34ab8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,5 @@ prime
 stage
 env
 ols-wheels
-*.snap
\ No newline at end of file
+*.snap
+*.egg-info/
diff --git a/Makefile b/Makefile
index 4a0769d..4bff705 100644
--- a/Makefile
+++ b/Makefile
@@ -3,6 +3,7 @@ ENV = $(CURDIR)/env
 PYTHON3 = $(ENV)/bin/python3
 PIP = $(PYTHON3) -m pip
 FLAKE8 = $(ENV)/bin/flake8
+BLACK = $(ENV)/bin/black
 
 DEPENDENCY_REPO ?= lp:~ubuntuone-pqm-team/ols-goodyear/+git/wheels
 OLS_WHEELS_DIR_TMP = $(CURDIR)/ols-wheels
@@ -24,11 +25,11 @@ $(ENV)/dev: $(ENV)/prod
 bootstrap: $(ENV)/prod
 
 snap:
-	snapcraft build
+	snapcraft
 
 test: $(ENV)/dev
 	$(PYTHON3) -m unittest $(TESTS) 2>&1
-	$(MAKE) --silent lint
+	$(MAKE) --silent black-check lint
 
 /snap/bin/documentation-builder:
 	sudo snap install documentation-builder
@@ -37,9 +38,15 @@ docs: /snap/bin/documentation-builder
 	documentation-builder --base-dir docs --output-path docs/build
 
 
-lint:
+lint: $(ENV)/dev
 	$(FLAKE8) $(SERVICE_PACKAGE)
 
+black: $(ENV)/dev
+	$(BLACK) .
+
+black-check: $(ENV)/dev
+	$(BLACK) --check .
+
 coverage: $(ENV)/dev
 	$(PYTHON3) -m coverage erase
 	$(PYTHON3) -m coverage run --include "$(SERVICE_PACKAGE)*" -m unittest $(TESTS)
diff --git a/requirements-dev.txt b/requirements-dev.txt
index f7b8ab9..72daeb2 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -5,3 +5,4 @@ flake8
 responses
 testscenarios
 testtools
+black
diff --git a/requirements.txt b/requirements.txt
index 09ae15a..0203da1 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,3 +2,5 @@ pymacaroons
 pysha3
 pyxdg
 requests
+click
+click_logging
\ No newline at end of file
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..778fa97
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,17 @@
+from setuptools import find_namespace_packages, setup
+
+
+with open("requirements.txt") as f:
+    install_requires = f.read().splitlines()
+
+setup(
+    name="snapstore",
+    version="1.1.0",
+    packages=find_namespace_packages(),
+    install_requires=install_requires,
+    entry_points={
+        "console_scripts": [
+            "snapstore = snapstore_client.cli:cli",
+        ],
+    },
+)
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index 8811c64..4563239 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,36 +1,26 @@
-name: snap-store-proxy-client
+name: snapstore-client
 base: core20
-version: "1.1"
 summary: Canonical snap store proxy administration client.
 description: |
   The Canonical snapstore client is used to manage a snap store proxy.
-
-# Defaults, but snapcraft prints ugly yellow messages without them.
 confinement: strict
 grade: stable
+adopt-info: source
 
 architectures:
   - build-on: amd64
 
 apps:
-  snap-store-proxy-client:
-    command: ./snapstore
+  snapstore:
+    command: bin/snapstore
     plugs:
       - network
 
 parts:
-  deps:
-    plugin: python
-    source: .
-    requirements:
-      - ${SNAPCRAFT_PART_SRC}/requirements.txt
   source:
-    plugin: dump
+    plugin: python
     source: .
-    stage:
-      - snapstore
-      - snapstore_client/
-    override-prime: |
-      snapcraftctl prime
-      python3 -m compileall -q -j0 snapstore_client
-
+    override-build: |
+        snapcraftctl build
+        version="$(python3 setup.py --version)"
+        snapcraftctl set-version "$version"
\ No newline at end of file
diff --git a/snapstore b/snapstore
deleted file mode 100755
index cd67b71..0000000
--- a/snapstore
+++ /dev/null
@@ -1,133 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Copyright 2017 Canonical Ltd.  This software is licensed under the
-# GNU General Public License version 3 (see the file LICENSE).
-
-"""CLI utility to manage a store-in-a-box installation."""
-
-import argparse
-import logging
-import os
-import sys
-
-from snapstore_client.cli import configure_logging
-from snapstore_client.logic.login import login
-from snapstore_client.logic.overrides import (
-    delete_override,
-    list_overrides,
-    override,
-)
-from snapstore_client.logic.push import push_snap
-
-
-DEFAULT_SSO_URL = 'https://login.ubuntu.com/'
-
-
-def main():
-    try:
-        configure_logging()
-        args = parse_args()
-        return args.func(args) or 0
-    except KeyboardInterrupt:
-        # use default logger as we can't guarantee that configuration
-        # has completed.
-        logging.error("Operation cancelled")
-        return 1
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(help='sub-command help')
-
-    login_parser = subparsers.add_parser(
-        'login', help='Sign into a store.',
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    login_parser.add_argument('store_url', help='Store URL')
-    login_parser.add_argument('email', help='Ubuntu One SSO email', nargs='?')
-    login_parser.add_argument('--sso-url', help='Ubuntu One SSO URL',
-                              default=DEFAULT_SSO_URL)
-    login_parser.add_argument('--offline', help="Use offline mode interaction",
-                              action='store_true')
-    login_parser.set_defaults(func=login)
-
-    list_overrides_parser = subparsers.add_parser(
-        'list-overrides', help='List channel map overrides.',
-    )
-    list_overrides_parser.add_argument(
-        '--series', default='16',
-        help='The series within which to list overrides.')
-    list_overrides_parser.add_argument(
-        'snap_name',
-        help='The name of the snap whose channel map should be listed.')
-    list_overrides_parser.add_argument(
-        '--password',
-        help='Password for interacting with an offline proxy',
-        default=os.environ.get('SNAP_PROXY_PASSWORD')
-    )
-    list_overrides_parser.set_defaults(func=list_overrides)
-
-    override_parser = subparsers.add_parser(
-        'override', help='Set channel map overrides.',
-    )
-    override_parser.add_argument(
-        '--series', default='16',
-        help='The series within which to set overrides.')
-    override_parser.add_argument(
-        'snap_name',
-        help='The name of the snap whose channel map should be modified.')
-    override_parser.add_argument(
-        'channel_map_entries', nargs='+', metavar='channel_map_entry',
-        help='A channel map override, in the form <channel>=<revision>.')
-    override_parser.add_argument(
-        '--password',
-        help='Password for interacting with an offline proxy',
-        default=os.environ.get('SNAP_PROXY_PASSWORD')
-    )
-    override_parser.set_defaults(func=override)
-
-    delete_override_parser = subparsers.add_parser(
-        'delete-override', help='Delete channel map overrides.',
-    )
-    delete_override_parser.add_argument(
-        '--series', default='16',
-        help='The series within which to delete overrides.')
-    delete_override_parser.add_argument(
-        'snap_name',
-        help='The name of the snap whose channel map should be modified.')
-    delete_override_parser.add_argument(
-        'channels', nargs='+', metavar='channel',
-        help='A channel whose overrides should be deleted.')
-    delete_override_parser.add_argument(
-        '--password',
-        help='Password for interacting with an offline proxy',
-        default=os.environ.get('SNAP_PROXY_PASSWORD')
-    )
-    delete_override_parser.set_defaults(func=delete_override)
-
-    push_snap_parser = subparsers.add_parser(
-        'push-snap', help='push a snap to an offline proxy')
-    push_snap_parser.add_argument(
-        'snap_tar_file',
-        help='The .tar.gz file of a bundled downloaded snap')
-    push_snap_parser.add_argument(
-        '--push-channel-map',
-        action='store_true',
-        help="Force push of the channel map,"
-             " removing any existing overrides")
-    push_snap_parser.add_argument(
-        '--password',
-        help='Password for interacting with an offline proxy',
-        default=os.environ.get('SNAP_PROXY_PASSWORD')
-    )
-    push_snap_parser.set_defaults(func=push_snap)
-
-    if len(sys.argv) == 1:
-        # Display help if no arguments are provided.
-        parser.print_help()
-        sys.exit(1)
-
-    return parser.parse_args()
-
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/snapstore_client/cli.py b/snapstore_client/cli.py
index 08008d0..f20c91b 100644
--- a/snapstore_client/cli.py
+++ b/snapstore_client/cli.py
@@ -1,67 +1,144 @@
-# Copyright 2017 Canonical Ltd.  This software is licensed under the
+# Copyright 2021 Canonical Ltd.  This software is licensed under the
 # GNU General Public License version 3 (see the file LICENSE).
 
 """Command-line interface niceties for this service."""
 
 import logging
-import os
-import sys
 
-
-class _StdoutFilter(logging.Filter):
-
-    def filter(self, record):
-        return record.levelno <= logging.WARNING
-
-
-class _StderrFilter(logging.Filter):
-
-    def filter(self, record):
-        return record.levelno >= logging.ERROR
-
-
-def _is_dumb_terminal():
-    """Return True if on a dumb terminal."""
-    is_stdout_tty = os.isatty(sys.stdout.fileno())
-    is_term_dumb = os.environ.get('TERM', '') == 'dumb'
-    return not is_stdout_tty or is_term_dumb
-
-
-class _ColouredFormatter(logging.Formatter):
-
-    _reset = '\033[0m'
-    _level_colours = {
-        'ERROR': '\033[0;31m',  # Dark red
-    }
-
-    def format(self, record):
-        colour = self._level_colours.get(record.levelname)
-        log_message = super().format(record)
-        if colour is not None:
-            return colour + log_message + self._reset
-        else:
-            return log_message
-
-
-def configure_logging(logger_name=None, log_level=logging.INFO):
-    stdout_handler = logging.StreamHandler(stream=sys.stdout)
-    stdout_handler.addFilter(_StdoutFilter())
-    stderr_handler = logging.StreamHandler(stream=sys.stderr)
-    stderr_handler.addFilter(_StderrFilter())
-    handlers = [stdout_handler, stderr_handler]
-    if _is_dumb_terminal():
-        formatter = logging.Formatter(style='{')
-    else:
-        formatter = _ColouredFormatter(style='{')
-    logger = logging.getLogger(logger_name)
-    for handler in handlers:
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-    logger.setLevel(log_level)
-
-    # The requests library is too noisy at INFO level.
-    if log_level == logging.DEBUG:
-        logging.getLogger('requests').setLevel(log_level)
-    else:
-        logging.getLogger('requests').setLevel(
-            max(logging.WARNING, log_level))
+logger = logging.getLogger(__name__)
+
+import click  # noqa: E402,E501
+import click_logging  # noqa: E402,E501
+
+from snapstore_client.logic import login as logic_login  # noqa: E402,E501
+from snapstore_client.logic.overrides import (  # noqa: E402,E501
+    list_overrides as logic_list_overrides,
+)
+from snapstore_client.logic.overrides import (  # noqa: E402,E501
+    override as logic_override,
+)
+from snapstore_client.logic.overrides import (  # noqa: E402,E501
+    delete_override as logic_delete_override,
+)
+from snapstore_client.logic import push  # noqa: E402,E501
+
+
+click_logging.basic_config(logger)
+
+
+DEFAULT_SSO_URL = "https://login.ubuntu.com/"
+
+
[e-mail]()
+@click_logging.simple_verbosity_option(logger=logger)
+def cli():
+    """This tool can be used to manage an (offline) snapstore proxy instance.
+
+    At the arguments that ask for an proxy password, it is possible to set
+    this in an environment variable called 'SNAP_PROX_PASSWORD'.
+    """
+    # Helper function to allow each subcommand be stand alone
+    pass
+
+
[e-mail]()
[e-mail]("store_url")
[e-mail]("email", required=False)
[e-mail]("--sso-url", help="Ubuntu One SSO URL", default=DEFAULT_SSO_URL)
[e-mail](
+    "--offline/--no-offline", help="Use offline mode interaction", default=False
+)
+def login(store_url, email, sso_url, offline):
+    """Login on a proxy
+
+    login arguments:
+
+    \b
+    STORE_URL : The snapstore proxy url
+    EMAIL     : Ubuntu ONE SSO email (optional)
+    """
+    logic_login.login(
+        store_url=store_url, email=email, sso_url=sso_url, offline=offline
+    )
+
+
[e-mail]()
[e-mail]("snap_name")
[e-mail]("--series", default=16, help="The series within which to list overrides.")
[e-mail](
+    "--password",
+    help="Password for interacting with an offline proxy",
+    envvar="SNAP_PROX_PASSWORD",
+)
+def list_overrides(snap_name, series, password):
+    """List channelmap overrides
+
+    List channelmap overrides for SNAP_NAME"""
+    logic_list_overrides(snap_name=snap_name, series=str(series), password=password)
+
+
[e-mail]()
[e-mail]("snap_name")
[e-mail]("channel_map_entries", nargs=-1, required=True)
[e-mail]("--series", default=16, help="The series within which to list overrides.")
[e-mail](
+    "--password",
+    help="Password for interacting with an offline proxy",
+    envvar="SNAP_PROX_PASSWORD",
+)
+def override(snap_name, channel_map_entries, series, password):
+    """Set channelmap overrides
+
+    Use CHANNEL_MAP_ENTRIES as SNAP_NAME overrides.
+
+    CHANNEL_MAP_ENTRIES takes form of <channel>=<revision>"""
+    logic_override(
+        snap_name=snap_name,
+        channel_map_entries=channel_map_entries,
+        series=str(series),
+        password=password,
+    )
+
+
[e-mail]()
[e-mail]("snap_name")
[e-mail]("channels", nargs=-1, required=True)
[e-mail]("--series", default=16, help="The series within which to list overrides.")
[e-mail](
+    "--password",
+    help="Password for interacting with an offline proxy",
+    envvar="SNAP_PROX_PASSWORD",
+)
+def delete_override(snap_name, channels, series, password):
+    """Delete a channelmap override
+
+    Delete overrides from SNAP_NAME for CHANNELS"""
+    logic_delete_override(
+        snap_name=snap_name,
+        channels=channels,
+        series=str(series),
+        password=password,
+    )
+
+
[e-mail]()
[e-mail]("snap_tar_file")
[e-mail](
+    "--push-channel-map",
+    default=False,
+    help="Force push of the channel map, removing any existing overrides",
+)
[e-mail](
+    "--password",
+    help="Password for interacting with an offline proxy",
+    envvar="SNAP_PROX_PASSWORD",
+)
+def push_snap(snap_tar_file, push_channel_map, password):
+    """Push tar bundle to proxy
+
+    Push SNAP_TAR_FILE (a .tar.gz file) to the proxy."""
+    push.push_snap(
+        snap_tar_file=snap_tar_file,
+        push_channel_map=push_channel_map,
+        password=password,
+    )
diff --git a/snapstore_client/config.py b/snapstore_client/config.py
index a01e975..636a3df 100644
--- a/snapstore_client/config.py
+++ b/snapstore_client/config.py
@@ -12,32 +12,27 @@ from xdg import BaseDirectory
 
 class Config:
 
-    xdg_name = 'snap-store-proxy-client'
+    xdg_name = "snap-store-proxy-client"
 
     def __init__(self):
         self.parser = configparser.ConfigParser()
         self.load()
 
     def load(self):
-        path = BaseDirectory.load_first_config(
-            self.xdg_name, 'config.ini')
+        path = BaseDirectory.load_first_config(self.xdg_name, "config.ini")
         if path is not None and os.path.exists(path):
             self.parser.read(path)
 
     def save(self):
-        path = os.path.join(
-            BaseDirectory.save_config_path(self.xdg_name),
-            'config.ini')
+        path = os.path.join(BaseDirectory.save_config_path(self.xdg_name), "config.ini")
         # TODO: better to write atomically
-        with open(path, 'w') as f:
+        with open(path, "w") as f:
             self.parser.write(f)
 
     def get(self, section, option):
         try:
             return self.parser.get(section, option)
-        except (configparser.NoSectionError,
-                configparser.NoOptionError,
-                KeyError):
+        except (configparser.NoSectionError, configparser.NoOptionError, KeyError):
             return None
 
     def set(self, section, option, value):
@@ -49,11 +44,10 @@ class Config:
         return Section(self, name)
 
     def store_section(self, name):
-        return Section(self, 'store:'+name)
+        return Section(self, "store:" + name)
 
 
 class Section:
-
     def __init__(self, config, name):
         self.config = config
         self.name = name
diff --git a/snapstore_client/exceptions.py b/snapstore_client/exceptions.py
index 061b5fe..d251fe5 100644
--- a/snapstore_client/exceptions.py
+++ b/snapstore_client/exceptions.py
@@ -21,7 +21,7 @@ class ClientError(Exception):
 
 class InvalidCredentials(ClientError):
 
-    fmt = 'Invalid credentials: {message}.'
+    fmt = "Invalid credentials: {message}."
 
     def __init__(self, message):
         super().__init__(message=message)
@@ -29,7 +29,7 @@ class InvalidCredentials(ClientError):
 
 class InvalidStoreURL(ClientError):
 
-    fmt = 'Invalid store url: {message}.'
+    fmt = "Invalid store url: {message}."
 
     def __init__(self, message):
         super().__init__(message=message)
@@ -37,7 +37,7 @@ class InvalidStoreURL(ClientError):
 
 class StoreCommunicationError(ClientError):
 
-    fmt = 'Connection error with the store using: {message}.'
+    fmt = "Connection error with the store using: {message}."
 
     def __init__(self, message):
         super().__init__(message=message)
@@ -45,7 +45,7 @@ class StoreCommunicationError(ClientError):
 
 class StoreMacaroonSSOMismatch(ClientError):
 
-    fmt = 'Root macaroon does not refer to expected SSO host: {sso_host}.'
+    fmt = "Root macaroon does not refer to expected SSO host: {sso_host}."
 
     def __init__(self, sso_host):
         super().__init__(sso_host=sso_host)
@@ -55,18 +55,17 @@ class StoreAuthenticationError(ClientError):
 
     # No terminating full stop because the message from SSO sometimes
     # (though not always!) includes one.
-    fmt = 'Authentication error: {message}'
+    fmt = "Authentication error: {message}"
 
     def __init__(self, message, extra=None):
         super().__init__(message=message, extra=extra)
 
 
 class StoreTwoFactorAuthenticationRequired(StoreAuthenticationError):
-
     def __init__(self):
-        super().__init__('Two-factor authentication required.')
+        super().__init__("Two-factor authentication required.")
 
 
 class StoreMacaroonNeedsRefresh(ClientError):
 
-    fmt = 'Authentication macaroon needs to be refreshed.'
+    fmt = "Authentication macaroon needs to be refreshed."
diff --git a/snapstore_client/logic/login.py b/snapstore_client/logic/login.py
index 9550988..bc91422 100644
--- a/snapstore_client/logic/login.py
+++ b/snapstore_client/logic/login.py
@@ -1,7 +1,6 @@
-# Copyright 2017 Canonical Ltd.
+# Copyright 2021 Canonical Ltd.
 
 import getpass
-import logging
 from urllib.parse import urlparse
 
 from pymacaroons import Macaroon
@@ -11,9 +10,7 @@ from snapstore_client import (
     exceptions,
     webservices as ws,
 )
-
-
-logger = logging.getLogger(__name__)
+from snapstore_client.cli import logger
 
 
 def _extract_caveat_id(sso_url, root_macaroon):
@@ -26,23 +23,21 @@ def _extract_caveat_id(sso_url, root_macaroon):
         raise exceptions.StoreMacaroonSSOMismatch(sso_host)
 
 
-def login(args):
+def login(store_url, email, sso_url, offline):
     # TODO: validate these before using to avoid ugly errors.
-    gw_url = args.store_url
-    sso_url = args.sso_url
+    gw_url = store_url
 
-    if args.offline:
+    if offline:
         cfg = config.Config()
-        store = cfg.store_section('default')
-        store.set('gw_url', gw_url)
+        store = cfg.store_section("default")
+        store.set("gw_url", gw_url)
         cfg.save()
         return
 
-    logger.info('Enter your Ubuntu One SSO credentials.')
-    email = args.email
+    logger.info("Enter your Ubuntu One SSO credentials.")
     if not email:
-        email = input('Email: ')
-    password = getpass.getpass('Password: ')
+        email = input("Email: ")
+    password = getpass.getpass("Password: ")
 
     try:
         root = ws.issue_store_admin(gw_url)
@@ -53,22 +48,23 @@ def login(args):
     try:
         try:
             unbound_discharge = ws.get_sso_discharge(
-                sso_url, email, password, caveat_id)
-            logger.info('Login successful')
+                sso_url, email, password, caveat_id
+            )
+            logger.info("Login successful")
         except exceptions.StoreTwoFactorAuthenticationRequired:
-            one_time_password = input('Second-factor auth: ')
+            one_time_password = input("Second-factor auth: ")
             unbound_discharge = ws.get_sso_discharge(
-                sso_url, email, password, caveat_id,
-                one_time_password=one_time_password)
-            logger.info('Login successful')
+                sso_url, email, password, caveat_id, one_time_password=one_time_password
+            )
+            logger.info("Login successful")
     except exceptions.StoreAuthenticationError as e:
-        logger.error('Login failed.')
-        logger.error('%s', e)
+        logger.error("Login failed.")
+        logger.error("%s", e)
         if e.extra:
             for key, value in e.extra.items():
                 if isinstance(value, list):
-                    value = ' '.join(value)
-                logger.error('%s: %s', key, value)
+                    value = " ".join(value)
+                logger.error("%s: %s", key, value)
         return 1
 
     cfg = config.Config()
@@ -76,12 +72,12 @@ def login(args):
     # to support multiple stores by allowing the user to provide a nice name
     # for a store at login that can be used to select the store for later
     # operations.
-    store = cfg.store_section('default')
-    store.set('gw_url', gw_url)
-    store.set('sso_url', sso_url)
-    store.set('root', root)
-    store.set('unbound_discharge', unbound_discharge)
-    store.set('email', email)
+    store = cfg.store_section("default")
+    store.set("gw_url", gw_url)
+    store.set("sso_url", sso_url)
+    store.set("root", root)
+    store.set("unbound_discharge", unbound_discharge)
+    store.set("email", email)
     cfg.save()
 
     return 0
diff --git a/snapstore_client/logic/overrides.py b/snapstore_client/logic/overrides.py
index d3c8356..e91a6e9 100644
--- a/snapstore_client/logic/overrides.py
+++ b/snapstore_client/logic/overrides.py
@@ -1,6 +1,4 @@
-# Copyright 2017 Canonical Ltd.
-
-import logging
+# Copyright 2021 Canonical Ltd.
 
 from requests.exceptions import HTTPError
 
@@ -20,94 +18,96 @@ from snapstore_client.utils import (
 )
 
 
-logger = logging.getLogger(__name__)
+from snapstore_client.cli import logger
 
 
-def list_overrides(args):
+def list_overrides(snap_name, series, password=None):
     cfg = config.Config()
     store = _check_default_store(cfg)
     if not store:
         return 1
 
     try:
-        if args.password:
+        if password:
             response = ws.get_overrides(
-                store, args.snap_name,
-                series=args.series, password=args.password)
+                store, snap_name, series=series, password=password
+            )
         else:
             response = ws.refresh_if_necessary(
-                store, ws.get_overrides,
-                store, args.snap_name, series=args.series)
+                store, ws.get_overrides, store, snap_name, series=series
+            )
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
     except HTTPError:
         _log_authorized_error()
         return 1
-    for override in response['overrides']:
+    for override in response["overrides"]:
         logger.info(override_to_string(override))
 
 
-def override(args):
+def override(snap_name, channel_map_entries, series, password):
     cfg = config.Config()
     store = _check_default_store(cfg)
     if not store:
         return 1
 
     overrides = []
-    for channel_map_entry in args.channel_map_entries:
+    for channel_map_entry in channel_map_entries:
         channel, revision = channel_map_string_to_tuple(channel_map_entry)
-        overrides.append({
-            'snap_name': args.snap_name,
-            'revision': revision,
-            'channel': channel,
-            'series': args.series,
-        })
+        overrides.append(
+            {
+                "snap_name": snap_name,
+                "revision": revision,
+                "channel": channel,
+                "series": series,
+            }
+        )
     try:
-        if args.password:
-            response = ws.set_overrides(
-                store, overrides, password=args.password)
+        if password:
+            response = ws.set_overrides(store, overrides, password=password)
         else:
             response = ws.refresh_if_necessary(
-                store, ws.set_overrides,
-                store, overrides)
+                store, ws.set_overrides, store, overrides
+            )
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
     except HTTPError:
         _log_authorized_error()
         return 1
-    for override in response['overrides']:
+    for override in response["overrides"]:
         logger.info(override_to_string(override))
 
 
-def delete_override(args):
+def delete_override(snap_name, channels, series, password):
     cfg = config.Config()
     store = _check_default_store(cfg)
     if not store:
         return 1
 
     overrides = []
-    for channel in args.channels:
-        overrides.append({
-            'snap_name': args.snap_name,
-            'revision': None,
-            'channel': channel,
-            'series': args.series,
-        })
+    for channel in channels:
+        overrides.append(
+            {
+                "snap_name": snap_name,
+                "revision": None,
+                "channel": channel,
+                "series": series,
+            }
+        )
     try:
-        if args.password:
-            response = ws.set_overrides(
-                store, overrides, password=args.password)
+        if password:
+            response = ws.set_overrides(store, overrides, password=password)
         else:
             response = ws.refresh_if_necessary(
-                store, ws.set_overrides,
-                store, overrides)
+                store, ws.set_overrides, store, overrides
+            )
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
     except HTTPError:
         _log_authorized_error()
         return 1
-    for override in response['overrides']:
+    for override in response["overrides"]:
         logger.info(override_to_string(override))
diff --git a/snapstore_client/logic/push.py b/snapstore_client/logic/push.py
index 1a91bbb..315b46d 100644
--- a/snapstore_client/logic/push.py
+++ b/snapstore_client/logic/push.py
@@ -1,3 +1,5 @@
+# Copyright 2021 Canonical Ltd.
+
 import json
 import logging
 from pathlib import Path
@@ -22,7 +24,7 @@ logger = logging.getLogger(__name__)
 
 
 # XXX twom 2019-03-19 hardcoded for now, awaiting RBAC integration
-USERNAME = 'admin'
+USERNAME = "admin"
 
 
 class pushException(Exception):
@@ -36,46 +38,46 @@ class ChannelMapExistsException(Exception):
 def _push_ident(store, password, downloaded_map):
     """push the snap details to snapident"""
 
-    snap_id = downloaded_map['snap-id']
-    snap_details = downloaded_map['snap']
+    snap_id = downloaded_map["snap-id"]
+    snap_details = downloaded_map["snap"]
     push_details = {
-        'snap_id': snap_id,
-        'package_type': 'snap',
-        'snap_name': snap_details['name'],
-        'private': False,  # If you're pushing to your own proxy
-        'stores': ['ubuntu'],  # ditto
-        'blob': snap_details,
-        'publisher_id': snap_details['publisher']['id'],
-        'publisher_name': snap_details['publisher']['display-name'],
-        'publisher_title': snap_details['publisher']['username'],
-        'publisher_validation': snap_details['publisher']['validation'],
-        'license': snap_details['license'],
-        'prices': snap_details['prices'],
-        'summary': snap_details['summary'],
-        'title': snap_details['title'],
+        "snap_id": snap_id,
+        "package_type": "snap",
+        "snap_name": snap_details["name"],
+        "private": False,  # If you're pushing to your own proxy
+        "stores": ["ubuntu"],  # ditto
+        "blob": snap_details,
+        "publisher_id": snap_details["publisher"]["id"],
+        "publisher_name": snap_details["publisher"]["display-name"],
+        "publisher_title": snap_details["publisher"]["username"],
+        "publisher_validation": snap_details["publisher"]["validation"],
+        "license": snap_details["license"],
+        "prices": snap_details["prices"],
+        "summary": snap_details["summary"],
+        "title": snap_details["title"],
     }
 
-    url = store.get('gw_url')
+    url = store.get("gw_url")
 
     response = requests.post(
-        url + '/snaps/update',
-        json={'snaps': [push_details]},
-        auth=requests.auth.HTTPBasicAuth(USERNAME, password)
+        url + "/snaps/update",
+        json={"snaps": [push_details]},
+        auth=requests.auth.HTTPBasicAuth(USERNAME, password),
     )
     if response.status_code != 200:
         raise pushException(
-            "Failure in pushing to snapident: {}".format(
-                response.content))
+            "Failure in pushing to snapident: {}".format(response.content)
+        )
 
 
 def _push_revs(store, password, downloaded_map):
     """push the revision information to snaprevs"""
-    store_url = store.get('gw_url')
+    store_url = store.get("gw_url")
 
-    snap_id = downloaded_map['snap-id']
-    for instance in downloaded_map['channel-map']:
+    snap_id = downloaded_map["snap-id"]
+    for instance in downloaded_map["channel-map"]:
         # rewrite the download_url
-        download_url = instance['download']['url']
+        download_url = instance["download"]["url"]
 
         url = urlsplit(download_url)
         fqdn = urlsplit(store_url)
@@ -84,90 +86,93 @@ def _push_revs(store, password, downloaded_map):
 
         # create the revision
         rev = {
-            'snap_id': snap_id,
-            'package_type': 'snap',
-            'revision': instance['revision'],
-            'version': instance['version'],
-            'confinement': instance['confinement'],
-            'architectures': instance['architectures'],
-            'created_at': instance['created-at'],
+            "snap_id": snap_id,
+            "package_type": "snap",
+            "revision": instance["revision"],
+            "version": instance["version"],
+            "confinement": instance["confinement"],
+            "architectures": instance["architectures"],
+            "created_at": instance["created-at"],
             # This is required, but isn't available to retrieve from /info
-            'created_by': '',
-            'binary_path': download_url,
-            'binary_filesize': instance['download']['size'],
-            'binary_sha3_384': instance['download']['sha3-384'],
-            'snap_yaml': instance.get('snap-yaml', ''),
-            'epoch': instance['epoch'],
-            'type': instance['type'],
-            'base': instance['base'],
-            'common_ids': instance['common-ids'],
+            "created_by": "",
+            "binary_path": download_url,
+            "binary_filesize": instance["download"]["size"],
+            "binary_sha3_384": instance["download"]["sha3-384"],
+            "snap_yaml": instance.get("snap-yaml", ""),
+            "epoch": instance["epoch"],
+            "type": instance["type"],
+            "base": instance["base"],
+            "common_ids": instance["common-ids"],
         }
         revs_response = requests.post(
-            store_url + '/revisions/create',
+            store_url + "/revisions/create",
             json=[rev],
-            auth=requests.auth.HTTPBasicAuth(USERNAME, password)
+            auth=requests.auth.HTTPBasicAuth(USERNAME, password),
         )
         # 409 / Conflict - already exists
         if revs_response.status_code not in [201, 409]:
             raise pushException(
                 "Failure to push revisions to snaprevs: {}".format(
-                    revs_response.content))
+                    revs_response.content
+                )
+            )
 
 
 def _push_channelmap(store, password, downloaded_map, force_push=False):
     """push the channel map to snaprevs"""
-    store_url = store.get('gw_url')
+    store_url = store.get("gw_url")
 
-    snap_id = downloaded_map['snap-id']
+    snap_id = downloaded_map["snap-id"]
 
     filter_payload = {
-        'filters': [
+        "filters": [
             {
-                'series': '16',
-                'package_type': 'snap',
-                'snap_id': snap_id,
+                "series": "16",
+                "package_type": "snap",
+                "snap_id": snap_id,
             },
         ],
     }
     # Check if we have an existing channel map
     existing = requests.post(
-        store_url + '/channelmaps/filter',
+        store_url + "/channelmaps/filter",
         json=filter_payload,
-        auth=requests.auth.HTTPBasicAuth(USERNAME, password))
+        auth=requests.auth.HTTPBasicAuth(USERNAME, password),
+    )
     if existing.status_code != 200:
         raise pushException("Error retrieving current channelmap")
-    if existing.json().get('channelmaps') and not force_push:
+    if existing.json().get("channelmaps") and not force_push:
         raise ChannelMapExistsException("Channel map already exists.")
 
-    for instance in downloaded_map['channel-map']:
-        if instance['channel']['track'] == 'latest':
+    for instance in downloaded_map["channel-map"]:
+        if instance["channel"]["track"] == "latest":
             track = None
         else:
-            track = instance['channel']['track']
+            track = instance["channel"]["track"]
         chan_map = {
             # This is wrong, it should be the current developer id
             # but the pusher might not be a developer
             # XXX (twom): can we get this from upstream?
-            'developer_id': downloaded_map['snap']['publisher']['id'],
-            'release_requests': [
+            "developer_id": downloaded_map["snap"]["publisher"]["id"],
+            "release_requests": [
                 {
-                    'package_type': 'snap',
-                    'snap_id': snap_id,
-                    'channel': [
+                    "package_type": "snap",
+                    "snap_id": snap_id,
+                    "channel": [
                         track,
-                        instance['channel']['risk'],
+                        instance["channel"]["risk"],
                         None,  # We can't deal in 'branch', it's not on the API
                     ],
-                    'architecture': instance['channel']['architecture'],
-                    'series': '16',
-                    'revision': instance['revision']
+                    "architecture": instance["channel"]["architecture"],
+                    "series": "16",
+                    "revision": instance["revision"],
                 }
-            ]
+            ],
         }
         map_response = requests.post(
-            store_url + '/channelmaps/update',
+            store_url + "/channelmaps/update",
             json=chan_map,
-            auth=requests.auth.HTTPBasicAuth(USERNAME, password)
+            auth=requests.auth.HTTPBasicAuth(USERNAME, password),
         )
         if map_response.status_code != 200:
             raise pushException("Error pushing channel map")
@@ -185,7 +190,7 @@ def _split_assertions(raw_contents):
     current_assert = []
     for line in raw_contents:
         # if we've encountered a new assert, save the old one, start a new one
-        if line.startswith('type: ') and current_assert:
+        if line.startswith("type: ") and current_assert:
             available_asserts.append(current_assert)
             current_assert = []
         current_assert.append(line)
@@ -196,33 +201,34 @@ def _split_assertions(raw_contents):
     # from between the concatenated asserts.
     # Remove it from the ones that have it so they're clean to push
     for assertion in available_asserts:
-        assertion[:] = assertion[:-1] if assertion[-1] == '' else assertion
+        assertion[:] = assertion[:-1] if assertion[-1] == "" else assertion
     return available_asserts
 
 
 def _add_assertion_to_service(store, password, list_assertions):
-    store_url = store.get('gw_url')
+    store_url = store.get("gw_url")
 
     # push the split asserts
     for assertion in list_assertions:
         # get the type
-        assert_type = assertion[0].split('type: ')[1]
+        assert_type = assertion[0].split("type: ")[1]
         # ignore the account-key of canonical, it's already a trusted assert
         # and will error on push
-        canonical_key = 'account-id: canonical'
-        if (assert_type == 'account-key' and canonical_key in assertion):
+        canonical_key = "account-id: canonical"
+        if assert_type == "account-key" and canonical_key in assertion:
             continue
-        if (assert_type == 'account' and canonical_key in assertion):
+        if assert_type == "account" and canonical_key in assertion:
             continue
         response = requests.post(
-            store_url + '/v1/assertions',
-            '\n'.join(assertion).encode('utf-8'),
-            headers={'Content-Type': 'application/x.ubuntu.assertion'},
-            auth=requests.auth.HTTPBasicAuth(USERNAME, password))
+            store_url + "/v1/assertions",
+            "\n".join(assertion).encode("utf-8"),
+            headers={"Content-Type": "application/x.ubuntu.assertion"},
+            auth=requests.auth.HTTPBasicAuth(USERNAME, password),
+        )
         if response.status_code != 201:
             raise pushException(
-                "Failed to push: {} - {}".format(
-                    response.status_code, response.content))
+                "Failed to push: {} - {}".format(response.status_code, response.content)
+            )
 
 
 def _push_assertions(store, password, assert_path):
@@ -241,13 +247,14 @@ def _push_assertions(store, password, assert_path):
 
 def _push_file_to_nginx_cache(store, password, snap_path, snap_id, revision):
     """Add the file to the nginx cache via the snapproxy service"""
-    store_url = store.get('gw_url')
-    target_filename = '{}_{}.snap'.format(snap_id, revision)
-    files = {target_filename: open(snap_path, 'rb')}
+    store_url = store.get("gw_url")
+    target_filename = "{}_{}.snap".format(snap_id, revision)
+    files = {target_filename: open(snap_path, "rb")}
     response = requests.post(
-        store_url + '/files/upload',
+        store_url + "/files/upload",
         files=files,
-        auth=requests.auth.HTTPBasicAuth(USERNAME, password))
+        auth=requests.auth.HTTPBasicAuth(USERNAME, password),
+    )
     if response.status_code != 200:
         print(response.status_code)
         raise pushException("Failed to push file to proxy cache")
@@ -259,10 +266,10 @@ def _push(store, tar_file, password, force_channel_map=False):
     to an offline proxy
     """
     extract_dir = Path(tempfile.mkdtemp())
-    with tarfile.open(str(tar_file), 'r:gz') as tar:
+    with tarfile.open(str(tar_file), "r:gz") as tar:
         tar.extractall(str(extract_dir))
 
-    json_file = extract_dir / 'channel-map.json'
+    json_file = extract_dir / "channel-map.json"
     json_path = Path(json_file)
     if not json_path.exists():
         logger.error("Snap information file not found at {}".format(json_path))
@@ -274,53 +281,54 @@ def _push(store, tar_file, password, force_channel_map=False):
     _push_ident(store, password, downloaded_map)
     _push_revs(store, password, downloaded_map)
     try:
-        _push_channelmap(
-            store, password, downloaded_map, force_channel_map)
+        _push_channelmap(store, password, downloaded_map, force_channel_map)
     except ChannelMapExistsException as e:
         logger.info(str(e))
         logger.info(
             "Not updating the channel map, either manage revisions using "
-            "`snap-proxy override` or try again with `--push-channel-map`")
-
-    for instance in downloaded_map['channel-map']:
-        snap_name = downloaded_map['snap']['name']
-        snap_file_name = '{}_{}.snap'.format(
-            snap_name, instance['revision'])
-        assert_file_name = '{}_{}.assert'.format(
-            snap_name, instance['revision'])
+            "`snap-proxy override` or try again with `--push-channel-map`"
+        )
+
+    for instance in downloaded_map["channel-map"]:
+        snap_name = downloaded_map["snap"]["name"]
+        snap_file_name = "{}_{}.snap".format(snap_name, instance["revision"])
+        assert_file_name = "{}_{}.assert".format(snap_name, instance["revision"])
         snap_path = str(json_path.parent / snap_file_name)
         assert_path = str(json_path.parent / assert_file_name)
         try:
             _push_file_to_nginx_cache(
-                store, password, snap_path,
-                downloaded_map['snap-id'], instance['revision'],
+                store,
+                password,
+                snap_path,
+                downloaded_map["snap-id"],
+                instance["revision"],
             )
         except FileNotFoundError as exc:
             logger.warning(
-                'Skipping revision %s (%s/%s) as %s not found',
-                instance['revision'],
-                instance['channel']['name'],
-                instance['channel']['architecture'],
+                "Skipping revision %s (%s/%s) as %s not found",
+                instance["revision"],
+                instance["channel"]["name"],
+                instance["channel"]["architecture"],
                 exc.filename,
             )
         else:
             _push_assertions(store, password, assert_path)
 
 
-def push_snap(args):
+def push_snap(snap_tar_file, push_channel_map, password):
     cfg = config.Config()
     store = _check_default_store(cfg)
     if not store:
         return 1
 
     try:
-        if args.password:
-            _push(store, args.snap_tar_file,
-                  args.password, args.push_channel_map)
+        if password:
+            _push(store, snap_tar_file, password, push_channel_map)
         else:
             logger.error(
                 "This command only works with a supplied password"
-                " and a proxy in offline mode")
+                " and a proxy in offline mode"
+            )
     except exceptions.InvalidCredentials as e:
         _log_credentials_error(e)
         return 1
diff --git a/snapstore_client/logic/tests/test_login.py b/snapstore_client/logic/tests/test_login.py
index d7854cc..a4a0fcc 100644
--- a/snapstore_client/logic/tests/test_login.py
+++ b/snapstore_client/logic/tests/test_login.py
@@ -19,268 +19,344 @@ from snapstore_client import (
     exceptions,
 )
 from snapstore_client.logic.login import login
-from snapstore_client.tests import factory
 
 
 class LoginTests(TestCase):
-
     def setUp(self):
         super().setUp()
-        self.default_gw_url = 'http://store.local/'
-        self.default_sso_url = 'https://login.staging.ubuntu.com/'
-        self.logger = self.useFixture(fixtures.FakeLogger())
+        self.default_gw_url = "http://store.local/"
+        self.default_sso_url = "https://login.staging.ubuntu.com/"
         self.config_path = self.useFixture(fixtures.TempDir()).path
-        self.useFixture(fixtures.MonkeyPatch(
-            'xdg.BaseDirectory.xdg_config_home', self.config_path))
-        self.useFixture(fixtures.MonkeyPatch(
-            'xdg.BaseDirectory.xdg_config_dirs', [self.config_path]))
-        self.mock_input = self.useFixture(fixtures.MockPatch(
-            'builtins.input')).mock
-        self.mock_getpass = self.useFixture(fixtures.MockPatch(
-            'getpass.getpass')).mock
+        self.useFixture(
+            fixtures.MonkeyPatch("xdg.BaseDirectory.xdg_config_home", self.config_path)
+        )
+        self.useFixture(
+            fixtures.MonkeyPatch(
+                "xdg.BaseDirectory.xdg_config_dirs", [self.config_path]
+            )
+        )
+        self.mock_input = self.useFixture(fixtures.MockPatch("builtins.input")).mock
+        self.mock_getpass = self.useFixture(fixtures.MockPatch("getpass.getpass")).mock
 
     def make_responses_callback(self, response_templates):
         full_responses = []
         for response in response_templates:
-            status = response.get('status', 200)
-            content_type = 'text/plain'
-            if 'json' in response:
-                content_type = 'application/json'
-                body = json.dumps(response['json'])
+            status = response.get("status", 200)
+            content_type = "text/plain"
+            if "json" in response:
+                content_type = "application/json"
+                body = json.dumps(response["json"])
             else:
-                body = response.get('body')
-            full_responses.append(
-                (status, {'Content-Type': content_type}, body))
+                body = response.get("body")
+            full_responses.append((status, {"Content-Type": content_type}, body))
         iter_responses = iter(full_responses)
         return lambda request: next(iter_responses)
 
-    def make_args(self, store_url=None,
-                  sso_url=None, email=None, offline=False):
-        return factory.Args(
-            store_url=store_url or self.default_gw_url,
-            sso_url=sso_url or self.default_sso_url,
-            email=email,
-            offline=offline,
-        )
+    def make_args(self, store_url=None, sso_url=None, email=None, offline=False):
+        return {
+            "store_url": store_url or self.default_gw_url,
+            "sso_url": sso_url or self.default_sso_url,
+            "email": email,
+            "offline": offline,
+        }
 
     def add_issue_store_admin_response(self, *response_templates, gw_url=None):
         gw_url = gw_url or self.default_gw_url
-        issue_store_admin_url = urljoin(gw_url, '/v2/auth/issue-store-admin')
+        issue_store_admin_url = urljoin(gw_url, "/v2/auth/issue-store-admin")
         responses.add_callback(
-            'POST', issue_store_admin_url,
-            self.make_responses_callback(response_templates))
+            "POST",
+            issue_store_admin_url,
+            self.make_responses_callback(response_templates),
+        )
 
-    def add_get_sso_discharge_response(self, *response_templates,
-                                       sso_url=None):
+    def add_get_sso_discharge_response(self, *response_templates, sso_url=None):
         sso_url = sso_url or self.default_sso_url
-        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
+        discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
         responses.add_callback(
-            'POST', discharge_url,
-            self.make_responses_callback(response_templates))
+            "POST", discharge_url, self.make_responses_callback(response_templates)
+        )
 
     def make_root_macaroon(self, sso_url=None):
         macaroon = Macaroon()
         sso_url = sso_url or self.default_sso_url
         sso_host = urlparse(sso_url).netloc
-        macaroon.add_third_party_caveat(sso_host, 'key', 'payload')
+        macaroon.add_third_party_caveat(sso_host, "key", "payload")
         return macaroon.serialize()
 
     @responses.activate
     def test_login_sso_mismatch(self):
-        self.mock_input.return_value = '[e-mail]'
-        self.mock_getpass.return_value = 'secret'
+        self.mock_input.return_value = "[e-mail]"
+        self.mock_getpass.return_value = "secret"
         macaroon = Macaroon()
-        macaroon.add_third_party_caveat('another.example.com', '', '')
+        macaroon.add_third_party_caveat("another.example.com", "", "")
         self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': macaroon.serialize()}})
-        self.add_get_sso_discharge_response({'status': 401})
+            {"status": 200, "json": {"macaroon": macaroon.serialize()}}
+        )
+        self.add_get_sso_discharge_response({"status": 401})
         self.assertRaises(
-            exceptions.StoreMacaroonSSOMismatch, login, self.make_args())
+            exceptions.StoreMacaroonSSOMismatch, login, **self.make_args()
+        )
 
     @responses.activate
     def test_login_sso_bad_email(self):
-        self.mock_input.return_value = ''
-        self.mock_getpass.return_value = ''
+        self.mock_input.return_value = ""
+        self.mock_getpass.return_value = ""
         self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': self.make_root_macaroon()}})
+            {"status": 200, "json": {"macaroon": self.make_root_macaroon()}}
+        )
         auth_error = {
-            'message': 'Invalid request data',
-            'extra': {'email': ['Enter a valid email address.']},
+            "message": "Invalid request data",
+            "extra": {"email": ["Enter a valid email address."]},
         }
-        self.add_get_sso_discharge_response(
-            {'status': 401, 'json': {'error_list': [auth_error]}})
-        self.assertEqual(1, login(self.make_args()))
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            self.add_get_sso_discharge_response(
+                {"status": 401, "json": {"error_list": [auth_error]}}
+            )
+            self.assertEqual(1, login(**self.make_args()))
         self.assertEqual(
-            'Enter your Ubuntu One SSO credentials.\n'
-            'Login failed.\n'
-            'Authentication error: Invalid request data\n'
-            'email: Enter a valid email address.\n',
-            self.logger.output)
+            [
+                "INFO:snapstore_client.cli:Enter your Ubuntu One SSO credentials.",
+                "ERROR:snapstore_client.cli:Login failed.",
+                "ERROR:snapstore_client.cli:Authentication error: Invalid request data",
+                "ERROR:snapstore_client.cli:email: Enter a valid email address.",
+            ],
+            logger.output,
+        )
 
     @responses.activate
     def test_login_sso_unauthorized(self):
-        self.mock_input.return_value = '[e-mail]'
-        self.mock_getpass.return_value = 'secret'
-        self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': self.make_root_macaroon()}})
-        auth_error = {'message': 'Provided email/password is not correct.'}
-        self.add_get_sso_discharge_response(
-            {'status': 401, 'json': {'error_list': [auth_error]}})
-        self.assertEqual(1, login(self.make_args()))
+        self.mock_input.return_value = "[e-mail]"
+        self.mock_getpass.return_value = "secret"
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            self.add_issue_store_admin_response(
+                {"status": 200, "json": {"macaroon": self.make_root_macaroon()}}
+            )
+            auth_error = {"message": "Provided email/password is not correct."}
+            self.add_get_sso_discharge_response(
+                {"status": 401, "json": {"error_list": [auth_error]}}
+            )
+            self.assertEqual(1, login(**self.make_args()))
         self.assertEqual(
-            'Enter your Ubuntu One SSO credentials.\n'
-            'Login failed.\n'
-            'Authentication error: Provided email/password is not correct.\n',
-            self.logger.output)
+            [
+                "INFO:snapstore_client.cli:Enter your Ubuntu One SSO credentials.",
+                "ERROR:snapstore_client.cli:Login failed.",
+                "ERROR:snapstore_client.cli:Authentication error: "
+                "Provided email/password is not correct.",
+            ],
+            logger.output,
+        )
 
     @responses.activate
     def test_login_twofactor_required(self):
-        self.mock_input.side_effect = ('[e-mail]', '123456')
-        self.mock_getpass.return_value = 'secret'
-        root = self.make_root_macaroon()
-        self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': root}})
-        self.add_get_sso_discharge_response(
-            {'status': 401,
-             'json': {'error_list': [{'code': 'twofactor-required'}]}},
-            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}})
-        self.assertEqual(0, login(self.make_args()))
+        self.mock_input.side_effect = ("[e-mail]", "123456")
+        self.mock_getpass.return_value = "secret"
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            root = self.make_root_macaroon()
+            self.add_issue_store_admin_response(
+                {"status": 200, "json": {"macaroon": root}}
+            )
+            self.add_get_sso_discharge_response(
+                {
+                    "status": 401,
+                    "json": {"error_list": [{"code": "twofactor-required"}]},
+                },
+                {"status": 200, "json": {"discharge_macaroon": "dummy"}},
+            )
+            self.assertEqual(0, login(**self.make_args()))
 
         self.assertIn(
-            'Enter your Ubuntu One SSO credentials.', self.logger.output)
-        self.mock_input.assert_has_calls([
-            mock.call('Email: '), mock.call('Second-factor auth: ')])
-        self.mock_getpass.assert_called_once_with('Password: ')
+            "INFO:snapstore_client.cli:Enter your Ubuntu One SSO credentials.",
+            logger.output,
+        )
+        self.mock_input.assert_has_calls(
+            [mock.call("Email: "), mock.call("Second-factor auth: ")]
+        )
+        self.mock_getpass.assert_called_once_with("Password: ")
         self.assertEqual(3, len(responses.calls))
-        self.assertEqual({
-            'email': '[e-mail]',
-            'password': 'secret',
-            'caveat_id': 'payload',
-        }, json.loads(responses.calls[1].request.body.decode()))
-        self.assertEqual({
-            'email': '[e-mail]',
-            'password': 'secret',
-            'caveat_id': 'payload',
-            'otp': '123456',
-        }, json.loads(responses.calls[2].request.body.decode()))
-        self.assertThat(config.Config().parser, ContainsDict({
-            'store:default': MatchesDict({
-                'gw_url': Equals(self.default_gw_url),
-                'sso_url': Equals(self.default_sso_url),
-                'root': Equals(root),
-                'unbound_discharge': Equals('dummy'),
-                'email': Equals('[e-mail]'),
-            }),
-        }))
+        self.assertEqual(
+            {
+                "email": "[e-mail]",
+                "password": "secret",
+                "caveat_id": "payload",
+            },
+            json.loads(responses.calls[1].request.body.decode()),
+        )
+        self.assertEqual(
+            {
+                "email": "[e-mail]",
+                "password": "secret",
+                "caveat_id": "payload",
+                "otp": "123456",
+            },
+            json.loads(responses.calls[2].request.body.decode()),
+        )
+        self.assertThat(
+            config.Config().parser,
+            ContainsDict(
+                {
+                    "store:default": MatchesDict(
+                        {
+                            "gw_url": Equals(self.default_gw_url),
+                            "sso_url": Equals(self.default_sso_url),
+                            "root": Equals(root),
+                            "unbound_discharge": Equals("dummy"),
+                            "email": Equals("[e-mail]"),
+                        }
+                    ),
+                }
+            ),
+        )
 
     @responses.activate
     def test_login_twofactor_not_required(self):
-        self.mock_input.return_value = '[e-mail]'
-        self.mock_getpass.return_value = 'secret'
-        root = self.make_root_macaroon()
-        self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': root}})
-        self.add_get_sso_discharge_response(
-            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}})
-        login(self.make_args())
+        self.mock_input.return_value = "[e-mail]"
+        self.mock_getpass.return_value = "secret"
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            root = self.make_root_macaroon()
+            self.add_issue_store_admin_response(
+                {"status": 200, "json": {"macaroon": root}}
+            )
+            self.add_get_sso_discharge_response(
+                {"status": 200, "json": {"discharge_macaroon": "dummy"}}
+            )
+            login(**self.make_args())
 
         self.assertIn(
-            'Enter your Ubuntu One SSO credentials.', self.logger.output)
-        self.mock_input.assert_called_once_with('Email: ')
-        self.mock_getpass.assert_called_once_with('Password: ')
+            "INFO:snapstore_client.cli:Enter your Ubuntu One SSO credentials.",
+            logger.output,
+        )
+        self.mock_input.assert_called_once_with("Email: ")
+        self.mock_getpass.assert_called_once_with("Password: ")
         self.assertEqual(2, len(responses.calls))
-        self.assertEqual({
-            'email': '[e-mail]',
-            'password': 'secret',
-            'caveat_id': 'payload',
-        }, json.loads(responses.calls[1].request.body.decode()))
-        self.assertThat(config.Config().parser, ContainsDict({
-            'store:default': MatchesDict({
-                'gw_url': Equals(self.default_gw_url),
-                'sso_url': Equals(self.default_sso_url),
-                'root': Equals(root),
-                'unbound_discharge': Equals('dummy'),
-                'email': Equals('[e-mail]'),
-            }),
-        }))
+        self.assertEqual(
+            {
+                "email": "[e-mail]",
+                "password": "secret",
+                "caveat_id": "payload",
+            },
+            json.loads(responses.calls[1].request.body.decode()),
+        )
+        self.assertThat(
+            config.Config().parser,
+            ContainsDict(
+                {
+                    "store:default": MatchesDict(
+                        {
+                            "gw_url": Equals(self.default_gw_url),
+                            "sso_url": Equals(self.default_sso_url),
+                            "root": Equals(root),
+                            "unbound_discharge": Equals("dummy"),
+                            "email": Equals("[e-mail]"),
+                        }
+                    ),
+                }
+            ),
+        )
 
     @responses.activate
     def test_login_with_email(self):
         self.mock_input.side_effect = Exception("shouldn't be called")
-        self.mock_getpass.return_value = 'secret'
-        root = self.make_root_macaroon()
-        self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': root}})
-        self.add_get_sso_discharge_response(
-            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}})
-        login(self.make_args(email='[e-mail]'))
+        self.mock_getpass.return_value = "secret"
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            root = self.make_root_macaroon()
+            self.add_issue_store_admin_response(
+                {"status": 200, "json": {"macaroon": root}}
+            )
+            self.add_get_sso_discharge_response(
+                {"status": 200, "json": {"discharge_macaroon": "dummy"}}
+            )
+            login(**self.make_args(email="[e-mail]"))
 
         self.assertIn(
-            'Enter your Ubuntu One SSO credentials.', self.logger.output)
+            "INFO:snapstore_client.cli:Enter your Ubuntu One SSO credentials.",
+            logger.output,
+        )
         self.mock_input.assert_not_called()
-        self.mock_getpass.assert_called_once_with('Password: ')
+        self.mock_getpass.assert_called_once_with("Password: ")
         self.assertEqual(2, len(responses.calls))
-        self.assertEqual({
-            'email': '[e-mail]',
-            'password': 'secret',
-            'caveat_id': 'payload',
-        }, json.loads(responses.calls[1].request.body.decode()))
-        self.assertThat(config.Config().parser, ContainsDict({
-            'store:default': MatchesDict({
-                'gw_url': Equals(self.default_gw_url),
-                'sso_url': Equals(self.default_sso_url),
-                'root': Equals(root),
-                'unbound_discharge': Equals('dummy'),
-                'email': Equals('[e-mail]'),
-            }),
-        }))
+        self.assertEqual(
+            {
+                "email": "[e-mail]",
+                "password": "secret",
+                "caveat_id": "payload",
+            },
+            json.loads(responses.calls[1].request.body.decode()),
+        )
+        self.assertThat(
+            config.Config().parser,
+            ContainsDict(
+                {
+                    "store:default": MatchesDict(
+                        {
+                            "gw_url": Equals(self.default_gw_url),
+                            "sso_url": Equals(self.default_sso_url),
+                            "root": Equals(root),
+                            "unbound_discharge": Equals("dummy"),
+                            "email": Equals("[e-mail]"),
+                        }
+                    ),
+                }
+            ),
+        )
 
     @responses.activate
     def test_store_url(self):
-        gw_url = 'http://otherstore.local:1234/'
+        gw_url = "http://otherstore.local:1234/"
 
-        self.mock_input.return_value = '[e-mail]'
-        self.mock_getpass.return_value = 'secret'
+        self.mock_input.return_value = "[e-mail]"
+        self.mock_getpass.return_value = "secret"
         root = self.make_root_macaroon()
         self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': root}}, gw_url=gw_url)
+            {"status": 200, "json": {"macaroon": root}}, gw_url=gw_url
+        )
         self.add_get_sso_discharge_response(
-            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}})
-        login(self.make_args(store_url=gw_url))
+            {"status": 200, "json": {"discharge_macaroon": "dummy"}}
+        )
+        login(**self.make_args(store_url=gw_url))
 
         self.assertEqual(2, len(responses.calls))
-        self.assertEqual(responses.calls[0].request.url[:len(gw_url)], gw_url)
-        self.assertTrue(
-            responses.calls[1].request.url.startswith(self.default_sso_url))
-        self.assertThat(config.Config().parser, ContainsDict({
-            'store:default': ContainsDict({
-                'gw_url': Equals(gw_url),
-                'sso_url': Equals(self.default_sso_url),
-            }),
-        }))
+        self.assertEqual(responses.calls[0].request.url[: len(gw_url)], gw_url)
+        self.assertTrue(responses.calls[1].request.url.startswith(self.default_sso_url))
+        self.assertThat(
+            config.Config().parser,
+            ContainsDict(
+                {
+                    "store:default": ContainsDict(
+                        {
+                            "gw_url": Equals(gw_url),
+                            "sso_url": Equals(self.default_sso_url),
+                        }
+                    ),
+                }
+            ),
+        )
 
     @responses.activate
     def test_sso_url(self):
-        sso_url = 'https://othersso.local:1234/'
+        sso_url = "https://othersso.local:1234/"
 
-        self.mock_input.return_value = '[e-mail]'
-        self.mock_getpass.return_value = 'secret'
+        self.mock_input.return_value = "[e-mail]"
+        self.mock_getpass.return_value = "secret"
         root = self.make_root_macaroon(sso_url=sso_url)
-        self.add_issue_store_admin_response(
-            {'status': 200, 'json': {'macaroon': root}})
+        self.add_issue_store_admin_response({"status": 200, "json": {"macaroon": root}})
         self.add_get_sso_discharge_response(
-            {'status': 200, 'json': {'discharge_macaroon': 'dummy'}},
-            sso_url=sso_url)
-        login(self.make_args(sso_url=sso_url))
+            {"status": 200, "json": {"discharge_macaroon": "dummy"}}, sso_url=sso_url
+        )
+        login(**self.make_args(sso_url=sso_url))
 
         self.assertEqual(2, len(responses.calls))
-        self.assertTrue(
-            responses.calls[0].request.url.startswith(self.default_gw_url))
-        self.assertEqual(
-            responses.calls[1].request.url[:len(sso_url)], sso_url)
-        self.assertThat(config.Config().parser, ContainsDict({
-            'store:default': ContainsDict({
-                'gw_url': Equals(self.default_gw_url),
-                'sso_url': Equals(sso_url),
-            }),
-        }))
+        self.assertTrue(responses.calls[0].request.url.startswith(self.default_gw_url))
+        self.assertEqual(responses.calls[1].request.url[: len(sso_url)], sso_url)
+        self.assertThat(
+            config.Config().parser,
+            ContainsDict(
+                {
+                    "store:default": ContainsDict(
+                        {
+                            "gw_url": Equals(self.default_gw_url),
+                            "sso_url": Equals(sso_url),
+                        }
+                    ),
+                }
+            ),
+        )
diff --git a/snapstore_client/logic/tests/test_overrides.py b/snapstore_client/logic/tests/test_overrides.py
index 05e32fc..78c9132 100644
--- a/snapstore_client/logic/tests/test_overrides.py
+++ b/snapstore_client/logic/tests/test_overrides.py
@@ -20,295 +20,366 @@ from snapstore_client.tests import (
 
 
 class OverridesTests(TestCase):
-
     def test_list_overrides_no_store_config(self):
         self.useFixture(testfixtures.ConfigFixture(empty=True))
         logger = self.useFixture(fixtures.FakeLogger())
-        rc = list_overrides(factory.Args(snap_name='some-snap', series='16'))
+        rc = list_overrides(snap_name="some-snap", series="16")
         self.assertEqual(rc, 1)
         self.assertEqual(
             logger.output,
-            'No store configuration found. '
-            'Have you run "snap-store-proxy-client login"?\n')
+            "No store configuration found. "
+            'Have you run "snap-store-proxy-client login"?\n',
+        )
 
     @responses.activate
     def test_list_overrides_online(self):
         self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
-        snap_id = factory.generate_snap_id()
-        overrides = [
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap'),
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=3,
-                upstream_revision=4, channel='foo/stable',
-                architecture='i386'),
-        ]
-        # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
-        # they exist.
-        overrides_url = urljoin(
-            config.Config().store_section('default').get('gw_url'),
-            '/v2/metadata/overrides/mysnap')
-        responses.add(
-            'GET', overrides_url, status=200, json={'overrides': overrides})
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            snap_id = factory.generate_snap_id()
+            overrides = [
+                factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id,
+                    snap_name="mysnap",
+                    revision=3,
+                    upstream_revision=4,
+                    channel="foo/stable",
+                    architecture="i386",
+                ),
+            ]
+            # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
+            # they exist.
+            overrides_url = urljoin(
+                config.Config().store_section("default").get("gw_url"),
+                "/v2/metadata/overrides/mysnap",
+            )
+            responses.add(
+                "GET", overrides_url, status=200, json={"overrides": overrides}
+            )
 
-        list_overrides(
-            factory.Args(snap_name='mysnap', series='16', password=False))
+            list_overrides(snap_name="mysnap", series="16", password=False)
         self.assertEqual(
-            'mysnap stable amd64 1 (upstream 2)\n'
-            'mysnap foo/stable i386 3 (upstream 4)\n',
-            logger.output)
+            [
+                "INFO:snapstore_client.cli:mysnap stable amd64 1 (upstream 2)",
+                "INFO:snapstore_client.cli:mysnap foo/stable i386 3 (upstream 4)",
+            ],
+            logger.output,
+        )
         # We shouldn't have Basic Authorization headers, but Macaroon
-        self.assertNotIn(
-            'Basic',
-            responses.calls[0].request.headers['Authorization'])
+        self.assertNotIn("Basic", responses.calls[0].request.headers["Authorization"])
 
     @responses.activate
     def test_list_overrides_offline(self):
         self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
-        snap_id = factory.generate_snap_id()
-        overrides = [
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap'),
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=3,
-                upstream_revision=4, channel='foo/stable',
-                architecture='i386'),
-        ]
-        # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
-        # they exist.
-        overrides_url = urljoin(
-            config.Config().store_section('default').get('gw_url'),
-            '/v2/metadata/overrides/mysnap')
-        responses.add(
-            'GET', overrides_url, status=200, json={'overrides': overrides})
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            snap_id = factory.generate_snap_id()
+            overrides = [
+                factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id,
+                    snap_name="mysnap",
+                    revision=3,
+                    upstream_revision=4,
+                    channel="foo/stable",
+                    architecture="i386",
+                ),
+            ]
+            # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
+            # they exist.
+            overrides_url = urljoin(
+                config.Config().store_section("default").get("gw_url"),
+                "/v2/metadata/overrides/mysnap",
+            )
+            responses.add(
+                "GET", overrides_url, status=200, json={"overrides": overrides}
+            )
 
-        list_overrides(
-            factory.Args(snap_name='mysnap', series='16', password='test'))
+            list_overrides(snap_name="mysnap", series="16", password="test")
         self.assertEqual(
-            'mysnap stable amd64 1 (upstream 2)\n'
-            'mysnap foo/stable i386 3 (upstream 4)\n',
-            logger.output)
+            [
+                "INFO:snapstore_client.cli:mysnap stable amd64 1 (upstream 2)",
+                "INFO:snapstore_client.cli:mysnap foo/stable i386 3 (upstream 4)",
+            ],
+            logger.output,
+        )
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==',
-            responses.calls[0].request.headers['Authorization'])
+            "Basic YWRtaW46dGVzdA==",
+            responses.calls[0].request.headers["Authorization"],
+        )
 
     def test_override_no_store_config(self):
         self.useFixture(testfixtures.ConfigFixture(empty=True))
         logger = self.useFixture(fixtures.FakeLogger())
-        rc = override(factory.Args(
-            snap_name='some-snap', channel_map_entries=['stable=1'],
-            series='16',
-            password=False))
+        rc = override(
+            snap_name="some-snap",
+            channel_map_entries=["stable=1"],
+            series="16",
+            password=False,
+        )
         self.assertEqual(rc, 1)
         self.assertEqual(
             logger.output,
-            'No store configuration found. '
-            'Have you run "snap-store-proxy-client login"?\n')
+            "No store configuration found. "
+            'Have you run "snap-store-proxy-client login"?\n',
+        )
 
     @responses.activate
     def test_override_online(self):
         self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
-        snap_id = factory.generate_snap_id()
-        overrides = [
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap'),
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=3,
-                upstream_revision=4, channel='foo/stable',
-                architecture='i386'),
-        ]
-        # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
-        # they exist.
-        overrides_url = urljoin(
-            config.Config().store_section('default').get('gw_url'),
-            '/v2/metadata/overrides')
-        responses.add(
-            'POST', overrides_url, status=200, json={'overrides': overrides})
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            snap_id = factory.generate_snap_id()
+            overrides = [
+                factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id,
+                    snap_name="mysnap",
+                    revision=3,
+                    upstream_revision=4,
+                    channel="foo/stable",
+                    architecture="i386",
+                ),
+            ]
+            # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
+            # they exist.
+            overrides_url = urljoin(
+                config.Config().store_section("default").get("gw_url"),
+                "/v2/metadata/overrides",
+            )
+            responses.add(
+                "POST", overrides_url, status=200, json={"overrides": overrides}
+            )
 
-        override(factory.Args(
-            snap_name='mysnap',
-            channel_map_entries=['stable=1', 'foo/stable=3'],
-            series='16',
-            password=False))
-        self.assertEqual([
-            {
-                'snap_name': 'mysnap',
-                'revision': 1,
-                'channel': 'stable',
-                'series': '16',
-            },
-            {
-                'snap_name': 'mysnap',
-                'revision': 3,
-                'channel': 'foo/stable',
-                'series': '16',
-            },
-        ], json.loads(responses.calls[0].request.body.decode()))
+            override(
+                snap_name="mysnap",
+                channel_map_entries=["stable=1", "foo/stable=3"],
+                series="16",
+                password=False,
+            )
+            self.assertEqual(
+                [
+                    {
+                        "snap_name": "mysnap",
+                        "revision": 1,
+                        "channel": "stable",
+                        "series": "16",
+                    },
+                    {
+                        "snap_name": "mysnap",
+                        "revision": 3,
+                        "channel": "foo/stable",
+                        "series": "16",
+                    },
+                ],
+                json.loads(responses.calls[0].request.body.decode()),
+            )
         self.assertEqual(
-            'mysnap stable amd64 1 (upstream 2)\n'
-            'mysnap foo/stable i386 3 (upstream 4)\n',
-            logger.output)
+            [
+                "INFO:snapstore_client.cli:mysnap stable amd64 1 (upstream 2)",
+                "INFO:snapstore_client.cli:mysnap foo/stable i386 3 (upstream 4)",
+            ],
+            logger.output,
+        )
         # We shouldn't have Basic Authorization headers, but Macaroon
-        self.assertNotIn(
-            'Basic',
-            responses.calls[0].request.headers['Authorization'])
+        self.assertNotIn("Basic", responses.calls[0].request.headers["Authorization"])
 
     @responses.activate
     def test_override_offline(self):
         self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
-        snap_id = factory.generate_snap_id()
-        overrides = [
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap'),
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=3,
-                upstream_revision=4, channel='foo/stable',
-                architecture='i386'),
-        ]
-        # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
-        # they exist.
-        overrides_url = urljoin(
-            config.Config().store_section('default').get('gw_url'),
-            '/v2/metadata/overrides')
-        responses.add(
-            'POST', overrides_url, status=200, json={'overrides': overrides})
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            snap_id = factory.generate_snap_id()
+            overrides = [
+                factory.SnapDeviceGateway.Override(snap_id=snap_id, snap_name="mysnap"),
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id,
+                    snap_name="mysnap",
+                    revision=3,
+                    upstream_revision=4,
+                    channel="foo/stable",
+                    architecture="i386",
+                ),
+            ]
+            # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
+            # they exist.
+            overrides_url = urljoin(
+                config.Config().store_section("default").get("gw_url"),
+                "/v2/metadata/overrides",
+            )
+            responses.add(
+                "POST", overrides_url, status=200, json={"overrides": overrides}
+            )
 
-        override(factory.Args(
-            snap_name='mysnap',
-            channel_map_entries=['stable=1', 'foo/stable=3'],
-            series='16',
-            password='test'))
-        self.assertEqual([
-            {
-                'snap_name': 'mysnap',
-                'revision': 1,
-                'channel': 'stable',
-                'series': '16',
-            },
-            {
-                'snap_name': 'mysnap',
-                'revision': 3,
-                'channel': 'foo/stable',
-                'series': '16',
-            },
-        ], json.loads(responses.calls[0].request.body.decode()))
+            override(
+                snap_name="mysnap",
+                channel_map_entries=["stable=1", "foo/stable=3"],
+                series="16",
+                password="test",
+            )
+            self.assertEqual(
+                [
+                    {
+                        "snap_name": "mysnap",
+                        "revision": 1,
+                        "channel": "stable",
+                        "series": "16",
+                    },
+                    {
+                        "snap_name": "mysnap",
+                        "revision": 3,
+                        "channel": "foo/stable",
+                        "series": "16",
+                    },
+                ],
+                json.loads(responses.calls[0].request.body.decode()),
+            )
         self.assertEqual(
-            'mysnap stable amd64 1 (upstream 2)\n'
-            'mysnap foo/stable i386 3 (upstream 4)\n',
-            logger.output)
+            [
+                "INFO:snapstore_client.cli:mysnap stable amd64 1 (upstream 2)",
+                "INFO:snapstore_client.cli:mysnap foo/stable i386 3 (upstream 4)",
+            ],
+            logger.output,
+        )
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==',
-            responses.calls[0].request.headers['Authorization'])
+            "Basic YWRtaW46dGVzdA==",
+            responses.calls[0].request.headers["Authorization"],
+        )
 
     def test_delete_override_no_store_config(self):
         self.useFixture(testfixtures.ConfigFixture(empty=True))
         logger = self.useFixture(fixtures.FakeLogger())
-        rc = delete_override(factory.Args(
-            snap_name='some-snap', channels=['stable'],
-            series='16', password=False))
+        rc = delete_override(
+            snap_name="some-snap", channels=["stable"], series="16", password=False
+        )
         self.assertEqual(rc, 1)
         self.assertEqual(
             logger.output,
-            'No store configuration found. '
-            'Have you run "snap-store-proxy-client login"?\n')
+            "No store configuration found. "
+            'Have you run "snap-store-proxy-client login"?\n',
+        )
 
     @responses.activate
     def test_delete_override_online(self):
         self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
-        snap_id = factory.generate_snap_id()
-        overrides = [
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=None),
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=None,
-                upstream_revision=4, channel='foo/stable',
-                architecture='i386'),
-        ]
-        # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
-        # they exist.
-        overrides_url = urljoin(
-            config.Config().store_section('default').get('gw_url'),
-            '/v2/metadata/overrides')
-        responses.add(
-            'POST', overrides_url, status=200, json={'overrides': overrides})
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            snap_id = factory.generate_snap_id()
+            overrides = [
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id, snap_name="mysnap", revision=None
+                ),
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id,
+                    snap_name="mysnap",
+                    revision=None,
+                    upstream_revision=4,
+                    channel="foo/stable",
+                    architecture="i386",
+                ),
+            ]
+            # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
+            # they exist.
+            overrides_url = urljoin(
+                config.Config().store_section("default").get("gw_url"),
+                "/v2/metadata/overrides",
+            )
+            responses.add(
+                "POST", overrides_url, status=200, json={"overrides": overrides}
+            )
 
-        delete_override(factory.Args(
-            snap_name='mysnap',
-            channels=['stable', 'foo/stable'],
-            series='16',
-            password=False))
-        self.assertEqual([
-            {
-                'snap_name': 'mysnap',
-                'revision': None,
-                'channel': 'stable',
-                'series': '16',
-            },
-            {
-                'snap_name': 'mysnap',
-                'revision': None,
-                'channel': 'foo/stable',
-                'series': '16',
-            },
-        ], json.loads(responses.calls[0].request.body.decode()))
+            delete_override(
+                snap_name="mysnap",
+                channels=["stable", "foo/stable"],
+                series="16",
+                password=False,
+            )
         self.assertEqual(
-            'mysnap stable amd64 is tracking upstream (revision 2)\n'
-            'mysnap foo/stable i386 is tracking upstream (revision 4)\n',
-            logger.output)
+            [
+                {
+                    "snap_name": "mysnap",
+                    "revision": None,
+                    "channel": "stable",
+                    "series": "16",
+                },
+                {
+                    "snap_name": "mysnap",
+                    "revision": None,
+                    "channel": "foo/stable",
+                    "series": "16",
+                },
+            ],
+            json.loads(responses.calls[0].request.body.decode()),
+        )
+        self.assertEqual(
+            [
+                "INFO:snapstore_client.cli:mysnap stable amd64 is tracking upstream "
+                "(revision 2)",
+                "INFO:snapstore_client.cli:mysnap foo/stable i386 is tracking upstream "
+                "(revision 4)",
+            ],
+            logger.output,
+        )
         # We shouldn't have Basic Authorization headers, but Macaroon
-        self.assertNotIn(
-            'Basic',
-            responses.calls[0].request.headers['Authorization'])
+        self.assertNotIn("Basic", responses.calls[0].request.headers["Authorization"])
 
     @responses.activate
     def test_delete_override_offline(self):
         self.useFixture(testfixtures.ConfigFixture())
-        logger = self.useFixture(fixtures.FakeLogger())
-        snap_id = factory.generate_snap_id()
-        overrides = [
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=None),
-            factory.SnapDeviceGateway.Override(
-                snap_id=snap_id, snap_name='mysnap', revision=None,
-                upstream_revision=4, channel='foo/stable',
-                architecture='i386'),
-        ]
-        # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
-        # they exist.
-        overrides_url = urljoin(
-            config.Config().store_section('default').get('gw_url'),
-            '/v2/metadata/overrides')
-        responses.add(
-            'POST', overrides_url, status=200, json={'overrides': overrides})
+        with self.assertLogs("snapstore_client.cli", "DEBUG") as logger:
+            snap_id = factory.generate_snap_id()
+            overrides = [
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id, snap_name="mysnap", revision=None
+                ),
+                factory.SnapDeviceGateway.Override(
+                    snap_id=snap_id,
+                    snap_name="mysnap",
+                    revision=None,
+                    upstream_revision=4,
+                    channel="foo/stable",
+                    architecture="i386",
+                ),
+            ]
+            # XXX cjwatson 2017-06-26: Use acceptable-generated doubles once
+            # they exist.
+            overrides_url = urljoin(
+                config.Config().store_section("default").get("gw_url"),
+                "/v2/metadata/overrides",
+            )
+            responses.add(
+                "POST", overrides_url, status=200, json={"overrides": overrides}
+            )
 
-        delete_override(factory.Args(
-            snap_name='mysnap',
-            channels=['stable', 'foo/stable'],
-            series='16',
-            password='test'))
-        self.assertEqual([
-            {
-                'snap_name': 'mysnap',
-                'revision': None,
-                'channel': 'stable',
-                'series': '16',
-            },
-            {
-                'snap_name': 'mysnap',
-                'revision': None,
-                'channel': 'foo/stable',
-                'series': '16',
-            },
-        ], json.loads(responses.calls[0].request.body.decode()))
+            delete_override(
+                snap_name="mysnap",
+                channels=["stable", "foo/stable"],
+                series="16",
+                password="test",
+            )
+        self.assertEqual(
+            [
+                {
+                    "snap_name": "mysnap",
+                    "revision": None,
+                    "channel": "stable",
+                    "series": "16",
+                },
+                {
+                    "snap_name": "mysnap",
+                    "revision": None,
+                    "channel": "foo/stable",
+                    "series": "16",
+                },
+            ],
+            json.loads(responses.calls[0].request.body.decode()),
+        )
         self.assertEqual(
-            'mysnap stable amd64 is tracking upstream (revision 2)\n'
-            'mysnap foo/stable i386 is tracking upstream (revision 4)\n',
-            logger.output)
+            [
+                "INFO:snapstore_client.cli:mysnap stable amd64 is tracking upstream "
+                "(revision 2)",
+                "INFO:snapstore_client.cli:mysnap foo/stable i386 is tracking upstream "
+                "(revision 4)",
+            ],
+            logger.output,
+        )
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==',
-            responses.calls[0].request.headers['Authorization'])
+            "Basic YWRtaW46dGVzdA==",
+            responses.calls[0].request.headers["Authorization"],
+        )
diff --git a/snapstore_client/logic/tests/test_push.py b/snapstore_client/logic/tests/test_push.py
index cda240c..e96088f 100644
--- a/snapstore_client/logic/tests/test_push.py
+++ b/snapstore_client/logic/tests/test_push.py
@@ -18,187 +18,201 @@ from snapstore_client.logic.push import (
 
 
 class pushTests(TestCase):
-
     def setUp(self):
         super().setUp()
-        self.default_gw_url = 'http://store.local'
+        self.default_gw_url = "http://store.local"
         self.logger = self.useFixture(fixtures.FakeLogger())
         current_path = Path(__file__).resolve().parent
-        with (current_path / 'test-snap-map.json').open() as fh:
+        with (current_path / "test-snap-map.json").open() as fh:
             self.snap_map = json.load(fh)
-        with (current_path / 'test-snap-assert.assert').open() as fh:
+        with (current_path / "test-snap-assert.assert").open() as fh:
             self.snap_assert = fh.read().splitlines()
-        self.store = {'gw_url': self.default_gw_url}
+        self.store = {"gw_url": self.default_gw_url}
 
     @responses.activate
     def test_push_ident(self):
-        ident_url = urljoin(self.default_gw_url, '/snaps/update')
-        responses.add('POST', ident_url, status=200)
+        ident_url = urljoin(self.default_gw_url, "/snaps/update")
+        responses.add("POST", ident_url, status=200)
 
-        _push_ident(self.store, 'test', self.snap_map)
+        _push_ident(self.store, "test", self.snap_map)
 
         request = responses.calls[0].request
-        payload = json.loads(request.body.decode('utf-8'))
+        payload = json.loads(request.body.decode("utf-8"))
 
         self.assertEqual(
-            payload['snaps'][0]['package_type'], 'snap',
+            payload["snaps"][0]["package_type"],
+            "snap",
         )
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==', request.headers['Authorization'],
+            "Basic YWRtaW46dGVzdA==",
+            request.headers["Authorization"],
         )
 
     @responses.activate
     def test_push_ident_failed(self):
-        ident_url = urljoin(self.default_gw_url, '/snaps/update')
-        responses.add('POST', ident_url, status=500)
+        ident_url = urljoin(self.default_gw_url, "/snaps/update")
+        responses.add("POST", ident_url, status=500)
 
-        self.assertRaises(
-            pushException, _push_ident, self.store, 'test', self.snap_map)
+        self.assertRaises(pushException, _push_ident, self.store, "test", self.snap_map)
 
     @responses.activate
     def test_push_revs(self):
-        revs_url = urljoin(self.default_gw_url, '/revisions/create')
-        responses.add('POST', revs_url, status=201)
+        revs_url = urljoin(self.default_gw_url, "/revisions/create")
+        responses.add("POST", revs_url, status=201)
 
-        _push_revs(self.store, 'test', self.snap_map)
+        _push_revs(self.store, "test", self.snap_map)
 
         request = responses.calls[0].request
-        payload = json.loads(request.body.decode('utf-8'))
+        payload = json.loads(request.body.decode("utf-8"))
 
-        self.assertEqual(payload[0]['package_type'], 'snap')
+        self.assertEqual(payload[0]["package_type"], "snap")
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==', request.headers['Authorization'],
+            "Basic YWRtaW46dGVzdA==",
+            request.headers["Authorization"],
         )
 
     @responses.activate
     def test_push_revs_unexpected_status_code(self):
-        revs_url = urljoin(self.default_gw_url, '/revisions/create')
-        responses.add('POST', revs_url, status=302)
+        revs_url = urljoin(self.default_gw_url, "/revisions/create")
+        responses.add("POST", revs_url, status=302)
 
-        self.assertRaises(
-            pushException, _push_revs, self.store, 'test', self.snap_map)
+        self.assertRaises(pushException, _push_revs, self.store, "test", self.snap_map)
 
     @responses.activate
     def test_push_revs_failed(self):
-        revs_url = urljoin(self.default_gw_url, '/revisions/create')
-        responses.add('POST', revs_url, status=500)
+        revs_url = urljoin(self.default_gw_url, "/revisions/create")
+        responses.add("POST", revs_url, status=500)
 
-        self.assertRaises(
-            pushException, _push_revs, self.store, 'test', self.snap_map)
+        self.assertRaises(pushException, _push_revs, self.store, "test", self.snap_map)
 
     @responses.activate
     def test_push_map(self):
-        filter_url = urljoin(self.default_gw_url, '/channelmaps/filter')
-        update_url = urljoin(self.default_gw_url, '/channelmaps/update')
-        responses.add('POST', filter_url, status=200, json={})
-        responses.add('POST', update_url, status=200)
+        filter_url = urljoin(self.default_gw_url, "/channelmaps/filter")
+        update_url = urljoin(self.default_gw_url, "/channelmaps/update")
+        responses.add("POST", filter_url, status=200, json={})
+        responses.add("POST", update_url, status=200)
 
-        _push_channelmap(self.store, 'test', self.snap_map)
+        _push_channelmap(self.store, "test", self.snap_map)
 
         filter_request = responses.calls[0].request
-        filter_payload = json.loads(filter_request.body.decode('utf-8'))
+        filter_payload = json.loads(filter_request.body.decode("utf-8"))
         self.assertEqual(
-            filter_payload['filters'],
+            filter_payload["filters"],
             [
                 {
-                    'series': '16',
-                    'package_type': 'snap',
-                    'snap_id': self.snap_map['snap-id'],
+                    "series": "16",
+                    "package_type": "snap",
+                    "snap_id": self.snap_map["snap-id"],
                 },
             ],
         )
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==', filter_request.headers['Authorization'],
+            "Basic YWRtaW46dGVzdA==",
+            filter_request.headers["Authorization"],
         )
 
         chanmap_update_request = responses.calls[1].request
         chanmap_update_payload = json.loads(
-            chanmap_update_request.body.decode('utf-8'),
+            chanmap_update_request.body.decode("utf-8"),
         )
         self.assertEqual(
-            chanmap_update_payload['release_requests'][0]['package_type'],
-            'snap',
+            chanmap_update_payload["release_requests"][0]["package_type"],
+            "snap",
         )
 
     @responses.activate
     def test_push_map_failed(self):
-        filter_url = urljoin(self.default_gw_url, '/channelmaps/filter')
-        update_url = urljoin(self.default_gw_url, '/channelmaps/update')
-        responses.add('POST', filter_url, status=200, json={})
-        responses.add('POST', update_url, status=500)
+        filter_url = urljoin(self.default_gw_url, "/channelmaps/filter")
+        update_url = urljoin(self.default_gw_url, "/channelmaps/update")
+        responses.add("POST", filter_url, status=200, json={})
+        responses.add("POST", update_url, status=500)
 
         self.assertRaises(
-            pushException, _push_channelmap,
-            self.store, 'test', self.snap_map)
+            pushException, _push_channelmap, self.store, "test", self.snap_map
+        )
 
     @responses.activate
     def test_push_map_exists(self):
-        filter_url = urljoin(self.default_gw_url, '/channelmaps/filter')
-        update_url = urljoin(self.default_gw_url, '/channelmaps/update')
-        exists = {'channelmaps': ['thing that exists']}
-        responses.add('POST', filter_url, status=200, json=exists)
-        responses.add('POST', update_url, status=200)
+        filter_url = urljoin(self.default_gw_url, "/channelmaps/filter")
+        update_url = urljoin(self.default_gw_url, "/channelmaps/update")
+        exists = {"channelmaps": ["thing that exists"]}
+        responses.add("POST", filter_url, status=200, json=exists)
+        responses.add("POST", update_url, status=200)
 
         self.assertRaises(
-            ChannelMapExistsException, _push_channelmap,
-            self.store, 'test', self.snap_map)
+            ChannelMapExistsException,
+            _push_channelmap,
+            self.store,
+            "test",
+            self.snap_map,
+        )
 
     @responses.activate
     def test_push_map_exists_force_push(self):
-        filter_url = urljoin(self.default_gw_url, '/channelmaps/filter')
-        update_url = urljoin(self.default_gw_url, '/channelmaps/update')
-        exists = {'channelmaps': ['thing that exists']}
-        responses.add('POST', filter_url, status=200, json=exists)
-        responses.add('POST', update_url, status=200)
+        filter_url = urljoin(self.default_gw_url, "/channelmaps/filter")
+        update_url = urljoin(self.default_gw_url, "/channelmaps/update")
+        exists = {"channelmaps": ["thing that exists"]}
+        responses.add("POST", filter_url, status=200, json=exists)
+        responses.add("POST", update_url, status=200)
 
-        _push_channelmap(self.store, 'test', self.snap_map, True)
+        _push_channelmap(self.store, "test", self.snap_map, True)
 
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==',
-            responses.calls[0].request.headers['Authorization'])
+            "Basic YWRtaW46dGVzdA==",
+            responses.calls[0].request.headers["Authorization"],
+        )
 
     def test_split_assertions(self):
         result = _split_assertions(self.snap_assert)
         assert len(result) == 4
 
         # We should have 4 different types of assertion
-        assert result[0][0] == 'type: account-key'
-        assert result[1][0] == 'type: account'
-        assert result[2][0] == 'type: snap-declaration'
-        assert result[3][0] == 'type: snap-revision'
+        assert result[0][0] == "type: account-key"
+        assert result[1][0] == "type: account"
+        assert result[2][0] == "type: snap-declaration"
+        assert result[3][0] == "type: snap-revision"
 
     @responses.activate
     def test_add_assertion_to_service(self):
-        assert_url = urljoin(self.default_gw_url, '/v1/assertions')
-        responses.add('POST', assert_url, status=201)
+        assert_url = urljoin(self.default_gw_url, "/v1/assertions")
+        responses.add("POST", assert_url, status=201)
 
         split_assertions = _split_assertions(self.snap_assert)
-        _add_assertion_to_service(self.store, 'test', split_assertions)
+        _add_assertion_to_service(self.store, "test", split_assertions)
 
         self.assertIn(
-            'display-name: Tom Wardill (Ω)',
-            responses.calls[0].request.body.decode('utf-8'),
+            "display-name: Tom Wardill (Ω)",
+            responses.calls[0].request.body.decode("utf-8"),
         )
         self.assertEqual(
-            'Basic YWRtaW46dGVzdA==',
-            responses.calls[0].request.headers['Authorization'])
+            "Basic YWRtaW46dGVzdA==",
+            responses.calls[0].request.headers["Authorization"],
+        )
 
     @responses.activate
     def test_add_assertion_to_service_unexpected_status_code(self):
-        assert_url = urljoin(self.default_gw_url, '/v1/assertions')
-        responses.add('POST', assert_url, status=302)
+        assert_url = urljoin(self.default_gw_url, "/v1/assertions")
+        responses.add("POST", assert_url, status=302)
 
         split_assertions = _split_assertions(self.snap_assert)
         self.assertRaises(
             pushException,
-            _add_assertion_to_service, self.store, 'test', split_assertions)
+            _add_assertion_to_service,
+            self.store,
+            "test",
+            split_assertions,
+        )
 
     @responses.activate
     def test_add_assertion_to_service_failed(self):
-        assert_url = urljoin(self.default_gw_url, '/v1/assertions')
-        responses.add('POST', assert_url, status=500)
+        assert_url = urljoin(self.default_gw_url, "/v1/assertions")
+        responses.add("POST", assert_url, status=500)
 
         split_assertions = _split_assertions(self.snap_assert)
         self.assertRaises(
             pushException,
-            _add_assertion_to_service, self.store, 'test', split_assertions)
+            _add_assertion_to_service,
+            self.store,
+            "test",
+            split_assertions,
+        )
diff --git a/snapstore_client/presentation_helpers.py b/snapstore_client/presentation_helpers.py
index 74e47b1..96846b7 100644
--- a/snapstore_client/presentation_helpers.py
+++ b/snapstore_client/presentation_helpers.py
@@ -17,7 +17,7 @@ def channel_map_string_to_tuple(channel_map_string):
 
     'edge=1' becomes ('edge', 1).
     """
-    parts = channel_map_string.rsplit('=', 1)
+    parts = channel_map_string.rsplit("=", 1)
     if len(parts) != 2:
         raise ValueError("Invalid channel map string: %r" % channel_map_string)
     channel = parts[0]
@@ -30,13 +30,13 @@ def channel_map_string_to_tuple(channel_map_string):
 
 def override_to_string(override):
     """Convert a channel map override into a string presentation."""
-    template = '{snap_name} {channel} {architecture}'
-    if override['revision'] is None:
-        template += ' is tracking upstream'
-        if override['upstream_revision'] is not None:
-            template += ' (revision {upstream_revision:d})'
+    template = "{snap_name} {channel} {architecture}"
+    if override["revision"] is None:
+        template += " is tracking upstream"
+        if override["upstream_revision"] is not None:
+            template += " (revision {upstream_revision:d})"
     else:
-        template += ' {revision:d}'
-        if override['upstream_revision'] is not None:
-            template += ' (upstream {upstream_revision:d})'
+        template += " {revision:d}"
+        if override["upstream_revision"] is not None:
+            template += " (upstream {upstream_revision:d})"
     return template.format_map(override)
diff --git a/snapstore_client/tests/factory.py b/snapstore_client/tests/factory.py
index f9d4ba5..f94ab1a 100644
--- a/snapstore_client/tests/factory.py
+++ b/snapstore_client/tests/factory.py
@@ -30,7 +30,7 @@ def generate_snap_id():
     This function does not check for duplicates.
 
     """
-    return ''.join(random.choice(SNAP_ID_ALPHABET) for _ in range(32))
+    return "".join(random.choice(SNAP_ID_ALPHABET) for _ in range(32))
 
 
 class APIError(Exception):
@@ -78,7 +78,7 @@ class APIError(Exception):
         return len(self._error_list) > 0
 
     def to_dict(self):
-        return {'error-list': [{'message': m} for m in self._error_list]}
+        return {"error-list": [{"message": m} for m in self._error_list]}
 
     @classmethod
     def single(cls, message):
@@ -90,21 +90,26 @@ class APIError(Exception):
 
 
 class SnapDeviceGateway:
-
     @staticmethod
-    def Override(snap_id=None, snap_name='special-sauce', revision=1,
-                 upstream_revision=2, channel='stable', architecture='amd64',
-                 series='16'):
+    def Override(
+        snap_id=None,
+        snap_name="special-sauce",
+        revision=1,
+        upstream_revision=2,
+        channel="stable",
+        architecture="amd64",
+        series="16",
+    ):
         if snap_id is None:
             snap_id = generate_snap_id()
         return {
-            'snap_id': snap_id,
-            'snap_name': snap_name,
-            'revision': revision,
-            'upstream_revision': upstream_revision,
-            'channel': channel,
-            'architecture': architecture,
-            'series': series,
+            "snap_id": snap_id,
+            "snap_name": snap_name,
+            "revision": revision,
+            "upstream_revision": upstream_revision,
+            "channel": channel,
+            "architecture": architecture,
+            "series": series,
         }
 
 
diff --git a/snapstore_client/tests/matchers.py b/snapstore_client/tests/matchers.py
index 29e10b7..baea1a6 100644
--- a/snapstore_client/tests/matchers.py
+++ b/snapstore_client/tests/matchers.py
@@ -22,19 +22,18 @@ class MacaroonsVerify(Matcher):
         self.key = key
 
     def match(self, macaroons):
-        mismatch = Contains('root').match(macaroons)
+        mismatch = Contains("root").match(macaroons)
         if mismatch is not None:
             return mismatch
-        root_macaroon = Macaroon.deserialize(macaroons['root'])
-        if 'discharge' in macaroons:
-            discharge_macaroons = [
-                Macaroon.deserialize(macaroons['discharge'])]
+        root_macaroon = Macaroon.deserialize(macaroons["root"])
+        if "discharge" in macaroons:
+            discharge_macaroons = [Macaroon.deserialize(macaroons["discharge"])]
         else:
             discharge_macaroons = []
         try:
             Verifier().verify(root_macaroon, self.key, discharge_macaroons)
         except Exception as e:
-            return Mismatch('Macaroons do not verify: %s' % e)
+            return Mismatch("Macaroons do not verify: %s" % e)
 
 
 class MacaroonHeaderVerifies(Matcher):
@@ -45,8 +44,9 @@ class MacaroonHeaderVerifies(Matcher):
         self.key = key
 
     def match(self, authz_header):
-        mismatch = StartsWith('Macaroon ').match(authz_header)
+        mismatch = StartsWith("Macaroon ").match(authz_header)
         if mismatch is not None:
             return mismatch
         return MacaroonsVerify(self.key).match(
-            parse_dict_header(authz_header[len('Macaroon '):]))
+            parse_dict_header(authz_header[len("Macaroon ") :])
+        )
diff --git a/snapstore_client/tests/test_cli.py b/snapstore_client/tests/test_cli.py
deleted file mode 100644
index a0b8257..0000000
--- a/snapstore_client/tests/test_cli.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# Copyright 2017 Canonical Ltd.  This software is licensed under the
-# GNU General Public License version 3 (see the file LICENSE).
-
-import logging
-
-import fixtures
-from testtools import TestCase
-
-from snapstore_client import cli
-
-
-class ConfigureLoggingTests(TestCase):
-
-    def setUp(self):
-        super().setUp()
-        self.logger = logging.getLogger(__name__)
-        self.addCleanup(
-            self._restoreLogger,
-            self.logger, self.logger.level, list(self.logger.handlers))
-        self.stdout = self.useFixture(fixtures.StringStream('stdout')).stream
-        self.stdout.fileno = lambda: 1
-        self.useFixture(fixtures.MonkeyPatch('sys.stdout', self.stdout))
-        self.stderr = self.useFixture(fixtures.StringStream('stderr')).stream
-        self.useFixture(fixtures.MonkeyPatch('sys.stderr', self.stderr))
-
-    @staticmethod
-    def _restoreLogger(logger, level, handlers):
-        logger.setLevel(logger.level)
-        for handler in list(logger.handlers):
-            logger.removeHandler(handler)
-        for handler in handlers:
-            logger.addHandler(handler)
-
-    def test_log_levels(self):
-        self.useFixture(fixtures.MonkeyPatch('os.isatty', lambda fd: True))
-        cli.configure_logging(__name__)
-        self.assertEqual(logging.INFO, self.logger.level)
-        self.logger.debug('Debug')
-        self.logger.info('Info')
-        self.logger.warning('Warning: %s', 'smoke')
-        self.logger.error('Error: %s', 'fire')
-        self.stdout.seek(0)
-        self.assertEqual('Info\nWarning: smoke\n', self.stdout.read())
-        self.stderr.seek(0)
-        self.assertEqual('\033[0;31mError: fire\033[0m\n', self.stderr.read())
-
-    def test_requests_log_level_default(self):
-        cli.configure_logging(__name__)
-        self.assertEqual(logging.WARNING, logging.getLogger('requests').level)
-
-    def test_requests_log_level_debug(self):
-        cli.configure_logging(__name__, logging.DEBUG)
-        self.assertEqual(logging.DEBUG, logging.getLogger('requests').level)
-
-    def test_requests_log_level_error(self):
-        cli.configure_logging(__name__, logging.ERROR)
-        self.assertEqual(logging.ERROR, logging.getLogger('requests').level)
-
-    def test_no_tty(self):
-        self.useFixture(fixtures.MonkeyPatch('os.isatty', lambda fd: False))
-        self.useFixture(fixtures.EnvironmentVariable('TERM', 'xterm'))
-        cli.configure_logging(__name__)
-        self.logger.error('Error: %s', 'fire')
-        self.stderr.seek(0)
-        self.assertEqual('Error: fire\n', self.stderr.read())
diff --git a/snapstore_client/tests/test_config.py b/snapstore_client/tests/test_config.py
index 320b51c..7243554 100644
--- a/snapstore_client/tests/test_config.py
+++ b/snapstore_client/tests/test_config.py
@@ -14,10 +14,9 @@ from snapstore_client.tests.testfixtures import (
 
 
 class ConfigTests(TestCase):
-
     def test_no_config(self):
         xdg_path = self.useFixture(XDGConfigDirFixture()).path
-        config_ini = os.path.join(xdg_path, Config.xdg_name, 'config.ini')
+        config_ini = os.path.join(xdg_path, Config.xdg_name, "config.ini")
         self.assertFalse(os.path.exists(config_ini))
         Config()
 
@@ -28,8 +27,7 @@ class ConfigTests(TestCase):
 
     def test_save(self):
         xdg_path = self.useFixture(XDGConfigDirFixture()).path
-        config_ini = os.path.join(
-            xdg_path, 'snap-store-proxy-client', 'config.ini')
+        config_ini = os.path.join(xdg_path, "snap-store-proxy-client", "config.ini")
         self.assertFalse(os.path.exists(config_ini))
 
         cfg = Config()
@@ -39,11 +37,16 @@ class ConfigTests(TestCase):
         self.assertTrue(os.path.exists(config_ini))
         with open(config_ini) as f:
             content = f.read()
-        self.assertEqual(content, dedent('''\
+        self.assertEqual(
+            content,
+            dedent(
+                """\
             [s]
             k = v
 
-        '''))
+        """
+            ),
+        )
 
     def test_get_missing(self):
         self.useFixture(XDGConfigDirFixture())
@@ -74,4 +77,5 @@ class ConfigTests(TestCase):
 
 def test_suite():
     from unittest import TestLoader
+
     return TestLoader().loadTestsFromName(__name__)
diff --git a/snapstore_client/tests/test_presentation_helpers.py b/snapstore_client/tests/test_presentation_helpers.py
index b46345d..7399f91 100644
--- a/snapstore_client/tests/test_presentation_helpers.py
+++ b/snapstore_client/tests/test_presentation_helpers.py
@@ -12,95 +12,125 @@ from snapstore_client.presentation_helpers import (
 class ChannelMapStringToTupleScenarioTests(WithScenarios, TestCase):
 
     scenarios = [
-        ('with risk', {
-            'channel_map': 'stable=1',
-            'terms': ('stable', 1),
-        }),
-        ('with track and risk', {
-            'channel_map': '2.1/stable=2',
-            'terms': ('2.1/stable', 2),
-        }),
-        ('with risk and branch', {
-            'channel_map': 'stable/hot-fix=42',
-            'terms': ('stable/hot-fix', 42),
-        }),
-        ('with track, risk and branch', {
-            'channel_map': '2.1/stable/hot-fix=123',
-            'terms': ('2.1/stable/hot-fix', 123),
-        }),
+        (
+            "with risk",
+            {
+                "channel_map": "stable=1",
+                "terms": ("stable", 1),
+            },
+        ),
+        (
+            "with track and risk",
+            {
+                "channel_map": "2.1/stable=2",
+                "terms": ("2.1/stable", 2),
+            },
+        ),
+        (
+            "with risk and branch",
+            {
+                "channel_map": "stable/hot-fix=42",
+                "terms": ("stable/hot-fix", 42),
+            },
+        ),
+        (
+            "with track, risk and branch",
+            {
+                "channel_map": "2.1/stable/hot-fix=123",
+                "terms": ("2.1/stable/hot-fix", 123),
+            },
+        ),
     ]
 
     def test_run_scenario(self):
-        self.assertEqual(
-            self.terms, channel_map_string_to_tuple(self.channel_map))
+        self.assertEqual(self.terms, channel_map_string_to_tuple(self.channel_map))
 
 
 class ChannelMapStringToTupleErrorTests(WithScenarios, TestCase):
 
     scenarios = [
-        ('missing revision', {
-            'channel_map': 'stable',
-            'error_message': "Invalid channel map string: 'stable'",
-        }),
-        ('non-integer revision', {
-            'channel_map': 'stable=nonsense',
-            'error_message': "Invalid revision string: 'nonsense'",
-        }),
+        (
+            "missing revision",
+            {
+                "channel_map": "stable",
+                "error_message": "Invalid channel map string: 'stable'",
+            },
+        ),
+        (
+            "non-integer revision",
+            {
+                "channel_map": "stable=nonsense",
+                "error_message": "Invalid revision string: 'nonsense'",
+            },
+        ),
     ]
 
     def test_run_scenario(self):
         error = self.assertRaises(
-            ValueError, channel_map_string_to_tuple, self.channel_map)
+            ValueError, channel_map_string_to_tuple, self.channel_map
+        )
         self.assertEqual(self.error_message, str(error))
 
 
 class OverrideToStringTests(WithScenarios, TestCase):
 
     scenarios = [
-        ('without revision or upstream revision', {
-            'override': {
-                'snap_id': 'dummy',
-                'snap_name': 'mysnap',
-                'revision': None,
-                'upstream_revision': None,
-                'channel': 'stable',
-                'architecture': 'amd64',
+        (
+            "without revision or upstream revision",
+            {
+                "override": {
+                    "snap_id": "dummy",
+                    "snap_name": "mysnap",
+                    "revision": None,
+                    "upstream_revision": None,
+                    "channel": "stable",
+                    "architecture": "amd64",
+                },
+                "string": "mysnap stable amd64 is tracking upstream",
             },
-            'string': 'mysnap stable amd64 is tracking upstream',
-        }),
-        ('without revision but with upstream revision', {
-            'override': {
-                'snap_id': 'dummy',
-                'snap_name': 'mysnap',
-                'revision': None,
-                'upstream_revision': 2,
-                'channel': 'stable',
-                'architecture': 'amd64',
+        ),
+        (
+            "without revision but with upstream revision",
+            {
+                "override": {
+                    "snap_id": "dummy",
+                    "snap_name": "mysnap",
+                    "revision": None,
+                    "upstream_revision": 2,
+                    "channel": "stable",
+                    "architecture": "amd64",
+                },
+                "string": "mysnap stable amd64 is tracking upstream (revision 2)",
             },
-            'string': 'mysnap stable amd64 is tracking upstream (revision 2)',
-        }),
-        ('with revision but without upstream revision', {
-            'override': {
-                'snap_id': 'dummy',
-                'snap_name': 'mysnap',
-                'revision': 1,
-                'upstream_revision': None,
-                'channel': 'stable',
-                'architecture': 'amd64',
+        ),
+        (
+            "with revision but without upstream revision",
+            {
+                "override": {
+                    "snap_id": "dummy",
+                    "snap_name": "mysnap",
+                    "revision": 1,
+                    "upstream_revision": None,
+                    "channel": "stable",
+                    "architecture": "amd64",
+                },
+                "string": "mysnap stable amd64 1",
             },
-            'string': 'mysnap stable amd64 1',
-        }),
-        ('with revision and upstream revision', {
-            'override': {
-                'snap_id': 'dummy',
-                'snap_name': 'mysnap',
-                'revision': 1,
-                'upstream_revision': 2,
-                'channel': 'stable',
-                'architecture': 'amd64',
+        ),
+        (
+            "with revision and upstream revision",
+            {
+                "override": {
+                    "snap_id": "dummy",
+                    "snap_name": "mysnap",
+                    "revision": 1,
+                    "upstream_revision": 2,
+                    "channel": "stable",
+                    "architecture": "amd64",
+                },
+                "string": "mysnap stable amd64 1 (upstream 2)",
             },
-            'string': 'mysnap stable amd64 1 (upstream 2)',
-        }),
+        ),
     ]
 
     def test_run_scenario(self):
diff --git a/snapstore_client/tests/test_webservices.py b/snapstore_client/tests/test_webservices.py
index c9c743c..ec2019d 100644
--- a/snapstore_client/tests/test_webservices.py
+++ b/snapstore_client/tests/test_webservices.py
@@ -20,127 +20,165 @@ from snapstore_client.tests import (
     testfixtures,
 )
 
-if sys.version < '3.6':
+if sys.version < "3.6":
     import sha3  # noqa
 
 
 class WebservicesTests(TestCase):
-
     def setUp(self):
         super().setUp()
         self.config = self.useFixture(testfixtures.ConfigFixture())
 
     @responses.activate
     def test_issue_store_admin_success(self):
-        gw_url = 'http://store.local/'
-        issue_store_admin_url = urljoin(gw_url, '/v2/auth/issue-store-admin')
+        gw_url = "http://store.local/"
+        issue_store_admin_url = urljoin(gw_url, "/v2/auth/issue-store-admin")
         responses.add(
-            'POST', issue_store_admin_url, status=200,
-            json={'macaroon': 'dummy'})
+            "POST", issue_store_admin_url, status=200, json={"macaroon": "dummy"}
+        )
 
-        self.assertEqual('dummy', webservices.issue_store_admin(gw_url))
+        self.assertEqual("dummy", webservices.issue_store_admin(gw_url))
 
     @responses.activate
     def test_issue_store_admin_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        gw_url = 'http://store.local/'
-        issue_store_admin_url = urljoin(gw_url, '/v2/auth/issue-store-admin')
+        gw_url = "http://store.local/"
+        issue_store_admin_url = urljoin(gw_url, "/v2/auth/issue-store-admin")
         responses.add(
-            'POST', issue_store_admin_url, status=400,
-            json=factory.APIError.single('Something went wrong').to_dict())
+            "POST",
+            issue_store_admin_url,
+            status=400,
+            json=factory.APIError.single("Something went wrong").to_dict(),
+        )
 
-        self.assertRaises(
-            HTTPError, webservices.issue_store_admin, gw_url)
+        self.assertRaises(HTTPError, webservices.issue_store_admin, gw_url)
         self.assertEqual(
-            'Failed to issue store_admin macaroon:\nSomething went wrong\n',
-            logger.output)
+            "Failed to issue store_admin macaroon:\nSomething went wrong\n",
+            logger.output,
+        )
 
     @responses.activate
     def test_get_sso_discharge_success(self):
-        sso_url = 'http://sso.local/'
-        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
+        sso_url = "http://sso.local/"
+        discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
         responses.add(
-            'POST', discharge_url, status=200,
-            json={'discharge_macaroon': 'dummy'})
+            "POST", discharge_url, status=200, json={"discharge_macaroon": "dummy"}
+        )
 
         self.assertEqual(
-            'dummy',
+            "dummy",
             webservices.get_sso_discharge(
-                sso_url, '[e-mail]', 'secret', 'caveat'))
+                sso_url, "[e-mail]", "secret", "caveat"
+            ),
+        )
         request = responses.calls[0].request
-        self.assertEqual('application/json', request.headers['Content-Type'])
-        self.assertEqual({
-            'email': '[e-mail]',
-            'password': 'secret',
-            'caveat_id': 'caveat',
-        }, json.loads(request.body.decode()))
+        self.assertEqual("application/json", request.headers["Content-Type"])
+        self.assertEqual(
+            {
+                "email": "[e-mail]",
+                "password": "secret",
+                "caveat_id": "caveat",
+            },
+            json.loads(request.body.decode()),
+        )
 
     @responses.activate
     def test_get_sso_discharge_success_with_otp(self):
-        sso_url = 'http://sso.local/'
-        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
+        sso_url = "http://sso.local/"
+        discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
         responses.add(
-            'POST', discharge_url, status=200,
-            json={'discharge_macaroon': 'dummy'})
+            "POST", discharge_url, status=200, json={"discharge_macaroon": "dummy"}
+        )
 
         self.assertEqual(
-            'dummy',
+            "dummy",
             webservices.get_sso_discharge(
-                sso_url, '[e-mail]', 'secret', 'caveat',
-                one_time_password='123456'))
+                sso_url,
+                "[e-mail]",
+                "secret",
+                "caveat",
+                one_time_password="123456",
+            ),
+        )
         request = responses.calls[0].request
-        self.assertEqual('application/json', request.headers['Content-Type'])
-        self.assertEqual({
-            'email': '[e-mail]',
-            'password': 'secret',
-            'caveat_id': 'caveat',
-            'otp': '123456',
-        }, json.loads(request.body.decode()))
+        self.assertEqual("application/json", request.headers["Content-Type"])
+        self.assertEqual(
+            {
+                "email": "[e-mail]",
+                "password": "secret",
+                "caveat_id": "caveat",
+                "otp": "123456",
+            },
+            json.loads(request.body.decode()),
+        )
 
     @responses.activate
     def test_get_sso_discharge_twofactor_required(self):
-        sso_url = 'http://sso.local/'
-        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
+        sso_url = "http://sso.local/"
+        discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
         responses.add(
-            'POST', discharge_url, status=401,
-            json={'error_list': [{'code': 'twofactor-required'}]})
+            "POST",
+            discharge_url,
+            status=401,
+            json={"error_list": [{"code": "twofactor-required"}]},
+        )
 
         self.assertRaises(
             exceptions.StoreTwoFactorAuthenticationRequired,
             webservices.get_sso_discharge,
-            sso_url, '[e-mail]', 'secret', 'caveat')
+            sso_url,
+            "[e-mail]",
+            "secret",
+            "caveat",
+        )
 
     @responses.activate
     def test_get_sso_discharge_structured_error(self):
-        sso_url = 'http://sso.local/'
-        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
+        sso_url = "http://sso.local/"
+        discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
         responses.add(
-            'POST', discharge_url, status=400,
-            json={'error_list': [{'code': 'invalid-request',
-                                  'message': 'Something went wrong'}]})
+            "POST",
+            discharge_url,
+            status=400,
+            json={
+                "error_list": [
+                    {"code": "invalid-request", "message": "Something went wrong"}
+                ]
+            },
+        )
 
         e = self.assertRaises(
-            exceptions.StoreAuthenticationError, webservices.get_sso_discharge,
-            sso_url, '[e-mail]', 'secret', 'caveat')
-        self.assertEqual('Something went wrong', e.message)
+            exceptions.StoreAuthenticationError,
+            webservices.get_sso_discharge,
+            sso_url,
+            "[e-mail]",
+            "secret",
+            "caveat",
+        )
+        self.assertEqual("Something went wrong", e.message)
 
     @responses.activate
     def test_get_sso_discharge_unstructured_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        sso_url = 'http://sso.local/'
-        discharge_url = urljoin(sso_url, '/api/v2/tokens/discharge')
-        responses.add(
-            'POST', discharge_url, status=503, body='Try again later.')
+        sso_url = "http://sso.local/"
+        discharge_url = urljoin(sso_url, "/api/v2/tokens/discharge")
+        responses.add("POST", discharge_url, status=503, body="Try again later.")
 
         self.assertRaises(
-            HTTPError, webservices.get_sso_discharge,
-            sso_url, '[e-mail]', 'secret', 'caveat')
+            HTTPError,
+            webservices.get_sso_discharge,
+            sso_url,
+            "[e-mail]",
+            "secret",
+            "caveat",
+        )
         self.assertEqual(
-            'Failed to get SSO discharge:\n'
-            '====================\n'
-            'Try again later.\n'
-            '====================\n',
-            logger.output)
+            "Failed to get SSO discharge:\n"
+            "====================\n"
+            "Try again later.\n"
+            "====================\n",
+            logger.output,
+        )
 
     @responses.activate
     def test_get_overrides_success(self):
@@ -148,33 +186,34 @@ class WebservicesTests(TestCase):
         overrides = [factory.SnapDeviceGateway.Override()]
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
-        store = config.Config().store_section('default')
-        overrides_url = urljoin(
-            store.get('gw_url'), '/v2/metadata/overrides/mysnap')
-        responses.add('GET', overrides_url, status=200, json=overrides)
+        store = config.Config().store_section("default")
+        overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides/mysnap")
+        responses.add("GET", overrides_url, status=200, json=overrides)
 
-        self.assertEqual(overrides, webservices.get_overrides(
-            store, 'mysnap'))
+        self.assertEqual(overrides, webservices.get_overrides(store, "mysnap"))
         request = responses.calls[0].request
         self.assertThat(
-            request.headers['Authorization'],
-            matchers.MacaroonHeaderVerifies(self.config.key))
-        self.assertNotIn('Failed to get overrides:', logger.output)
+            request.headers["Authorization"],
+            matchers.MacaroonHeaderVerifies(self.config.key),
+        )
+        self.assertNotIn("Failed to get overrides:", logger.output)
 
     @responses.activate
     def test_get_overrides_error(self):
         logger = self.useFixture(fixtures.FakeLogger())
-        store = config.Config().store_section('default')
-        overrides_url = urljoin(
-            store.get('gw_url'), '/v2/metadata/overrides/mysnap')
+        store = config.Config().store_section("default")
+        overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides/mysnap")
         responses.add(
-            'GET', overrides_url, status=400,
-            json=factory.APIError.single('Something went wrong').to_dict())
+            "GET",
+            overrides_url,
+            status=400,
+            json=factory.APIError.single("Something went wrong").to_dict(),
+        )
 
-        self.assertRaises(
-            HTTPError, webservices.get_overrides, store, 'mysnap')
+        self.assertRaises(HTTPError, webservices.get_overrides, store, "mysnap")
         self.assertEqual(
-            'Failed to get overrides:\nSomething went wrong\n', logger.output)
+            "Failed to get overrides:\nSomething went wrong\n", logger.output
+        )
 
     @responses.activate
     def test_set_overrides_success(self):
@@ -182,28 +221,41 @@ class WebservicesTests(TestCase):
         override = factory.SnapDeviceGateway.Override()
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
-        store = config.Config().store_section('default')
-        overrides_url = urljoin(store.get('gw_url'), '/v2/metadata/overrides')
-        responses.add('POST', overrides_url, status=200, json=[override])
-
-        self.assertEqual([override], webservices.set_overrides(
-            store, [{
-                'snap_name': override['snap_name'],
-                'revision': override['revision'],
-                'channel': override['channel'],
-                'series': override['series'],
-            }]))
+        store = config.Config().store_section("default")
+        overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides")
+        responses.add("POST", overrides_url, status=200, json=[override])
+
+        self.assertEqual(
+            [override],
+            webservices.set_overrides(
+                store,
+                [
+                    {
+                        "snap_name": override["snap_name"],
+                        "revision": override["revision"],
+                        "channel": override["channel"],
+                        "series": override["series"],
+                    }
+                ],
+            ),
+        )
         request = responses.calls[0].request
         self.assertThat(
-            request.headers['Authorization'],
-            matchers.MacaroonHeaderVerifies(self.config.key))
-        self.assertEqual([{
-            'snap_name': override['snap_name'],
-            'revision': override['revision'],
-            'channel': override['channel'],
-            'series': override['series'],
-        }], json.loads(request.body.decode()))
-        self.assertNotIn('Failed to set override:', logger.output)
+            request.headers["Authorization"],
+            matchers.MacaroonHeaderVerifies(self.config.key),
+        )
+        self.assertEqual(
+            [
+                {
+                    "snap_name": override["snap_name"],
+                    "revision": override["revision"],
+                    "channel": override["channel"],
+                    "series": override["series"],
+                }
+            ],
+            json.loads(request.body.decode()),
+        )
+        self.assertNotIn("Failed to set override:", logger.output)
 
     @responses.activate
     def test_set_overrides_error(self):
@@ -211,18 +263,27 @@ class WebservicesTests(TestCase):
         override = factory.SnapDeviceGateway.Override()
         # XXX cjwatson 2017-06-26: Use acceptable-generated double once it
         # exists.
-        store = config.Config().store_section('default')
-        overrides_url = urljoin(store.get('gw_url'), '/v2/metadata/overrides')
+        store = config.Config().store_section("default")
+        overrides_url = urljoin(store.get("gw_url"), "/v2/metadata/overrides")
         responses.add(
-            'POST', overrides_url, status=400,
-            json=factory.APIError.single('Something went wrong').to_dict())
-
-        self.assertRaises(HTTPError, lambda: webservices.set_overrides(
-            store, {
-                'snap_name': override['snap_name'],
-                'revision': override['revision'],
-                'channel': override['channel'],
-                'series': override['series'],
-            }))
+            "POST",
+            overrides_url,
+            status=400,
+            json=factory.APIError.single("Something went wrong").to_dict(),
+        )
+
+        self.assertRaises(
+            HTTPError,
+            lambda: webservices.set_overrides(
+                store,
+                {
+                    "snap_name": override["snap_name"],
+                    "revision": override["revision"],
+                    "channel": override["channel"],
+                    "series": override["series"],
+                },
+            ),
+        )
         self.assertEqual(
-            'Failed to set override:\nSomething went wrong\n', logger.output)
+            "Failed to set override:\nSomething went wrong\n", logger.output
+        )
diff --git a/snapstore_client/tests/testfixtures.py b/snapstore_client/tests/testfixtures.py
index 10f714e..68daabf 100644
--- a/snapstore_client/tests/testfixtures.py
+++ b/snapstore_client/tests/testfixtures.py
@@ -14,11 +14,11 @@ from pymacaroons import Macaroon
 
 
 class NowFixture(MonkeyPatch):
-
     def __init__(self):
         self.now = datetime.datetime.now()
         super().__init__(
-            'datetime.datetime', types.SimpleNamespace(now=lambda: self.now))
+            "datetime.datetime", types.SimpleNamespace(now=lambda: self.now)
+        )
 
 
 class XDGConfigDirFixture(Fixture):
@@ -28,42 +28,43 @@ class XDGConfigDirFixture(Fixture):
 
     def _setUp(self):
         self.path = self.useFixture(TempDir()).path
-        self.useFixture(MonkeyPatch(
-            'xdg.BaseDirectory.xdg_config_home', self.path))
-        self.useFixture(MonkeyPatch(
-            'xdg.BaseDirectory.xdg_config_dirs', [self.path]))
+        self.useFixture(MonkeyPatch("xdg.BaseDirectory.xdg_config_home", self.path))
+        self.useFixture(MonkeyPatch("xdg.BaseDirectory.xdg_config_dirs", [self.path]))
 
 
 class ConfigFixture(Fixture):
-
     def __init__(self, empty=False):
         super().__init__()
         self.empty = empty
-        self.gw_url = 'http://store.local/'
-        self.sso_url = 'http://sso.local/'
-        self.key = 'random-key'
+        self.gw_url = "http://store.local/"
+        self.sso_url = "http://sso.local/"
+        self.key = "random-key"
         self.root = Macaroon(key=self.key)
-        self.root.add_third_party_caveat(
-            'login.example.com', 'sso-key', 'payload')
+        self.root.add_third_party_caveat("login.example.com", "sso-key", "payload")
         self.unbound_discharge = Macaroon(
-            location='login.example.com', identifier='payload', key='sso-key')
+            location="login.example.com", identifier="payload", key="sso-key"
+        )
 
     def _setUp(self):
         xdg_config_path = self.useFixture(XDGConfigDirFixture()).path
-        app_config_path = os.path.join(
-            xdg_config_path, 'snap-store-proxy-client')
+        app_config_path = os.path.join(xdg_config_path, "snap-store-proxy-client")
         os.makedirs(app_config_path)
         if self.empty:
             return
-        with open(os.path.join(app_config_path, 'config.ini'), 'w') as f:
-            f.write(dedent("""
+        with open(os.path.join(app_config_path, "config.ini"), "w") as f:
+            f.write(
+                dedent(
+                    """
                 [store:default]
                 gw_url = {gw_url}
                 sso_url = {sso_url}
                 root = {root}
                 unbound_discharge = {unbound_discharge}
-            """).format(
-                gw_url=self.gw_url, sso_url=self.sso_url,
-                root=self.root.serialize(),
-                unbound_discharge=self.unbound_discharge.serialize(),
-            ))
+            """
+                ).format(
+                    gw_url=self.gw_url,
+                    sso_url=self.sso_url,
+                    root=self.root.serialize(),
+                    unbound_discharge=self.unbound_discharge.serialize(),
+                )
+            )
diff --git a/snapstore_client/utils.py b/snapstore_client/utils.py
index 461a1c3..1922e60 100644
--- a/snapstore_client/utils.py
+++ b/snapstore_client/utils.py
@@ -4,23 +4,25 @@ logger = logging.getLogger(__name__)
 
 
 def _log_credentials_error(e):
-    logger.error('%s', e)
+    logger.error("%s", e)
     logger.error('Try to "snap-store-proxy-client login" again.')
 
 
 def _log_authorized_error():
-    logger.error(("Perhaps you have not been registered as an "
-                  "admin with the proxy."))
+    logger.error(
+        ("Perhaps you have not been registered as an " "admin with the proxy.")
+    )
     logger.error("Try 'snap-proxy add-admin' on the proxy host.")
 
 
 def _check_default_store(cfg):
     """Load the default store from the config."""
-    store = cfg.store_section('default')
+    store = cfg.store_section("default")
     # If the gw URL is configured then everything else should be too.
-    if not store.get('gw_url'):
+    if not store.get("gw_url"):
         logger.error(
-            'No store configuration found. '
-            'Have you run "snap-store-proxy-client login"?')
+            "No store configuration found. "
+            'Have you run "snap-store-proxy-client login"?'
+        )
         return None
     return store
diff --git a/snapstore_client/webservices.py b/snapstore_client/webservices.py
index 3ebf149..687d67f 100644
--- a/snapstore_client/webservices.py
+++ b/snapstore_client/webservices.py
@@ -17,8 +17,7 @@ logger = logging.getLogger(__name__)
 
 def issue_store_admin(gw_url):
     """Ask the store to issue a store_admin macaroon."""
-    issue_store_admin_url = urllib.parse.urljoin(
-        gw_url, '/v2/auth/issue-store-admin')
+    issue_store_admin_url = urllib.parse.urljoin(gw_url, "/v2/auth/issue-store-admin")
     try:
         resp = requests.post(issue_store_admin_url)
     except requests.exceptions.ConnectionError:
@@ -26,94 +25,93 @@ def issue_store_admin(gw_url):
     except requests.exceptions.RequestException:
         raise exceptions.InvalidStoreURL(gw_url)
     if resp.status_code == 404:
-        _print_error_message('issue store_admin macaroon', resp)
+        _print_error_message("issue store_admin macaroon", resp)
         raise exceptions.InvalidStoreURL(gw_url)
     elif resp.status_code != 200:
-        _print_error_message('issue store_admin macaroon', resp)
+        _print_error_message("issue store_admin macaroon", resp)
         resp.raise_for_status()
-    return resp.json()['macaroon']
+    return resp.json()["macaroon"]
 
 
-def get_sso_discharge(sso_url, email, password, caveat_id,
-                      one_time_password=None):
-    discharge_url = urllib.parse.urljoin(
-        sso_url, '/api/v2/tokens/discharge')
-    data = {'email': email, 'password': password, 'caveat_id': caveat_id}
+def get_sso_discharge(sso_url, email, password, caveat_id, one_time_password=None):
+    discharge_url = urllib.parse.urljoin(sso_url, "/api/v2/tokens/discharge")
+    data = {"email": email, "password": password, "caveat_id": caveat_id}
     if one_time_password is not None:
-        data['otp'] = one_time_password
+        data["otp"] = one_time_password
     resp = requests.post(
-        discharge_url, headers={'Accept': 'application/json'}, json=data)
+        discharge_url, headers={"Accept": "application/json"}, json=data
+    )
     if not resp.ok:
         try:
-            error_list = resp.json().get('error_list', [])
+            error_list = resp.json().get("error_list", [])
             if resp.status_code == 401:
                 for error in error_list:
-                    if error.get('code') == 'twofactor-required':
+                    if error.get("code") == "twofactor-required":
                         raise exceptions.StoreTwoFactorAuthenticationRequired()
             if error_list:
                 # Only bother about the first error.
                 error = error_list[0]
                 raise exceptions.StoreAuthenticationError(
-                    error['message'], extra=error.get('extra'))
+                    error["message"], extra=error.get("extra")
+                )
         except json.JSONDecodeError:
             pass
-        _print_error_message('get SSO discharge', resp)
+        _print_error_message("get SSO discharge", resp)
         resp.raise_for_status()
-    return resp.json()['discharge_macaroon']
+    return resp.json()["discharge_macaroon"]
 
 
 def refresh_sso_discharge(store, unbound_discharge_raw):
-    refresh_url = urllib.parse.urljoin(
-        store.get('sso_url'), '/api/v2/tokens/refresh')
-    data = {'discharge_macaroon': unbound_discharge_raw}
-    resp = requests.post(
-        refresh_url, headers={'Accept': 'application/json'}, json=data)
+    refresh_url = urllib.parse.urljoin(store.get("sso_url"), "/api/v2/tokens/refresh")
+    data = {"discharge_macaroon": unbound_discharge_raw}
+    resp = requests.post(refresh_url, headers={"Accept": "application/json"}, json=data)
     if not resp.ok:
-        _print_error_message('refresh SSO discharge', resp)
+        _print_error_message("refresh SSO discharge", resp)
         resp.raise_for_status()
-    return resp.json()['discharge_macaroon']
+    return resp.json()["discharge_macaroon"]
 
 
 def _deserialize_macaroon(name, value):
     if value is None:
-        raise exceptions.InvalidCredentials('no {} macaroon'.format(name))
+        raise exceptions.InvalidCredentials("no {} macaroon".format(name))
     try:
         return Macaroon.deserialize(value)
     except Exception:
         raise exceptions.InvalidCredentials(
-            'failed to deserialize {} macaroon'.format(name))
+            "failed to deserialize {} macaroon".format(name)
+        )
 
 
 def _get_macaroon_auth(store):
     """Return an Authorization header containing store macaroons."""
-    root_raw = store.get('root')
-    root = _deserialize_macaroon('root', root_raw)
-    unbound_discharge_raw = store.get('unbound_discharge')
+    root_raw = store.get("root")
+    root = _deserialize_macaroon("root", root_raw)
+    unbound_discharge_raw = store.get("unbound_discharge")
     unbound_discharge = _deserialize_macaroon(
-        'unbound discharge', unbound_discharge_raw)
+        "unbound discharge", unbound_discharge_raw
+    )
     bound_discharge = root.prepare_for_request(unbound_discharge)
     bound_discharge_raw = bound_discharge.serialize()
-    return 'Macaroon root="{}", discharge="{}"'.format(
-        root_raw, bound_discharge_raw)
+    return 'Macaroon root="{}", discharge="{}"'.format(root_raw, bound_discharge_raw)
 
 
 def _get_basic_auth(password):
     """Build the basic auth for interacting with an offline proxy"""
     # XXX twom 2019-03-15 Hardcoded username, awaiting user management
-    username = 'admin'
-    credentials = '{}:{}'.format(username, password)
+    username = "admin"
+    credentials = "{}:{}".format(username, password)
     try:
-        encoded_credentials = base64.b64encode(credentials.encode('UTF-8'))
+        encoded_credentials = base64.b64encode(credentials.encode("UTF-8"))
     except UnicodeEncodeError:
-        logger.error('Unable to encode password to UTF-8')
+        logger.error("Unable to encode password to UTF-8")
         raise
-    return 'Basic {}'.format(encoded_credentials.decode())
+    return "Basic {}".format(encoded_credentials.decode())
 
 
 def _raise_needs_refresh(response):
-    if (response.status_code == 401 and
-            response.headers.get('WWW-Authenticate') == (
-                'Macaroon needs_refresh=1')):
+    if response.status_code == 401 and response.headers.get("WWW-Authenticate") == (
+        "Macaroon needs_refresh=1"
+    ):
         raise exceptions.StoreMacaroonNeedsRefresh()
 
 
@@ -123,44 +121,45 @@ def refresh_if_necessary(store, func, *args, **kwargs):
         return func(*args, **kwargs)
     except exceptions.StoreMacaroonNeedsRefresh:
         unbound_discharge = refresh_sso_discharge(
-            store.get('sso_url'), store.get('unbound_discharge'))
-        store.set('unbound_discharge', unbound_discharge)
+            store.get("sso_url"), store.get("unbound_discharge")
+        )
+        store.set("unbound_discharge", unbound_discharge)
         store.save()
         return func(*args, **kwargs)
 
 
-def get_overrides(store, snap_name, series='16', password=None):
+def get_overrides(store, snap_name, series="16", password=None):
     """Get all overrides for a snap."""
     overrides_url = urllib.parse.urljoin(
-        store.get('gw_url'),
-        '/v2/metadata/overrides/{}'.format(urllib.parse.quote_plus(snap_name)))
+        store.get("gw_url"),
+        "/v2/metadata/overrides/{}".format(urllib.parse.quote_plus(snap_name)),
+    )
     headers = {
-        'X-Ubuntu-Series': series,
+        "X-Ubuntu-Series": series,
     }
     if password:
-        headers['Authorization'] = _get_basic_auth(password)
+        headers["Authorization"] = _get_basic_auth(password)
     else:
-        headers['Authorization'] = _get_macaroon_auth(store)
+        headers["Authorization"] = _get_macaroon_auth(store)
     resp = requests.get(overrides_url, headers=headers)
     _raise_needs_refresh(resp)
     if resp.status_code != 200:
-        _print_error_message('get overrides', resp)
+        _print_error_message("get overrides", resp)
         resp.raise_for_status()
     return resp.json()
 
 
 def set_overrides(store, overrides, password=None):
     """Add or remove channel map overrides for a snap."""
-    overrides_url = urllib.parse.urljoin(
-        store.get('gw_url'), '/v2/metadata/overrides')
+    overrides_url = urllib.parse.urljoin(store.get("gw_url"), "/v2/metadata/overrides")
     if password:
-        headers = {'Authorization': _get_basic_auth(password)}
+        headers = {"Authorization": _get_basic_auth(password)}
     else:
-        headers = {'Authorization': _get_macaroon_auth(store)}
+        headers = {"Authorization": _get_macaroon_auth(store)}
     resp = requests.post(overrides_url, headers=headers, json=overrides)
     _raise_needs_refresh(resp)
     if resp.status_code != 200:
-        _print_error_message('set override', resp)
+        _print_error_message("set override", resp)
         resp.raise_for_status()
     return resp.json()
 
@@ -176,10 +175,11 @@ def _print_error_message(action, response):
         try:
             json_document = response.json()
             error_list = json_document.get(
-                'error-list', json_document.get('error_list', []))
+                "error-list", json_document.get("error_list", [])
+            )
             for error in error_list:
-                logger.error(error['message'])
+                logger.error(error["message"])
         except json.JSONDecodeError:
-            logger.error('=' * 20)
-            logger.error(response.content.decode('UTF-8', errors='replace'))
-            logger.error('=' * 20)
+            logger.error("=" * 20)
+            logger.error(response.content.decode("UTF-8", errors="replace"))
+            logger.error("=" * 20)