Merge ~cjwatson/snapstore-client:webservices-tests into snapstore-client:master

[Colin Watson]

Add webservices tests

[Matt Goodall (matt-goodall)]

looks good. some minor comments, mostly optional and/or pedantic :)

review: Approve

[Colin Watson (cjwatson)]

Fixed most of that except where commented, thanks.

diff --git a/requirements-dev.txt b/requirements-dev.txt
index 49a3c2a..c29ab6e 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,4 +1,8 @@
+acceptable>=0.9
 coverage
 fixtures
 flake8
+pysha3>=1.0
+responses
+snapstore-schemas
 testtools
diff --git a/snapstore_client/tests/factory.py b/snapstore_client/tests/factory.py
new file mode 100644
index 0000000..e733cfa
--- /dev/null
+++ b/snapstore_client/tests/factory.py
@@ -0,0 +1,252 @@
+# Copyright 2017 Canonical Ltd.
+
+"""Test Factory.
+
+Since siab-client does not have any database, its persistence layer consists
+of making requests to other services in the store.
+
+The test factory therefore makes it easy to create payloads that are
+consistent with what those other services return from their various API
+endpoints.
+
+Factory functions are grouped into classes, one for each service.
+"""
+
+import random
+import string
+
+
+SNAP_ID_ALPHABET = string.ascii_letters + string.digits
+
+
+def generate_snap_id():
+    """Generate a random ID to identify a snap entity.
+
+    The id is a sequence of 32 random characters taken out of an alphabet
+    of 62 characters (uppercase letters + lowercase letters + numbers), for
+    a total of 310 bits of space. These unique identifiers are generated
+    centrally or delegated to known parties.
+
+    This function does not check for duplicates.
+
+    """
+    return ''.join(random.choice(SNAP_ID_ALPHABET) for _ in range(32))
+
+
+class APIError(Exception):
+    """The base class for all user-visible exceptions.
+
+    The snapident presentation layer knows how to transform instances of this
+    exception to HTTP responses in a common format. This exception is designed
+    to contain one *or more* error messages. The exception can be created with
+    a list of messages and an HTTP status code:
+
+    >>> raise APIError(["error one", "error two", "error three"])
+
+    This is useful when the full list of errors to raise is known at once.
+
+    However, a second approach exists, which is to create an empty APIError
+    instance, and iteratively add errors over time:
+
+    >>> errors = APIError.empty()
+    >>> for thing in list:
+    ...     if some_error_condition:
+    ...         errors.add_error("Some error message")
+    ...
+    >>> if errors:
+    ...     raise errors
+
+    The 'truthieness' of the exception instance is determined by at least one
+    error message having been added.
+
+    Another common case is needing to raise a single error. It's mildly
+    inconvenient to have to specify a single-item list all the time, so there's
+    a convenience function to make that easier:
+
+    >>> raise APIError.single("Some message")
+    """
+
+    status_code = 400
+
+    def __init__(self, error_list):
+        self._error_list = error_list
+
+    def add_error(self, error_message):
+        self._error_list.append(error_message)
+
+    def __bool__(self):
+        return len(self._error_list) > 0
+
+    def to_dict(self):
+        return {'error_list': [{'message': m} for m in self._error_list]}
+
+    @classmethod
+    def single(cls, message):
+        return cls([message])
+
+    @classmethod
+    def empty(cls):
+        return cls([])
+
+
+class SnapIdentBuilder:
+
+    def __init__(self):
+        self.snaps = []
+
+    def get_payload(self):
+        return {'snaps': self.snaps}
+
+    def add_snap(self, snap_name=None, snap_id=None, series=None,
+                 authority=None, private=None, publisher_id=None, stores=None,
+                 status=None, country_blacklist=None, country_whitelist=None,
+                 blob=None):
+        snap_name = snap_name or 'special-sauce'
+        snap_id = snap_id or generate_snap_id()
+        self.snaps.append({
+            'snap_id': snap_id,
+            'snap_name': snap_name,
+            'series': series or '16',
+            'blob': blob or self.generate_blob(snap_name),
+            'authority': authority or 'local-authority',
+            'private': private or False,
+            'publisher_id': publisher_id or 'some-publisher-id',
+            'stores': stores or ['some-store-id'],
+            'status': status or 'published',
+            'country_blacklist': country_blacklist or [],
+            'country_whitelist': country_whitelist or [],
+        })
+
+    @staticmethod
+    def generate_blob(snap_name):
+        """Generate a payload as returned from snapident's fetch-blob endpoint.
+
+        The 'blob' in this example has been trimmed to only contain the
+        values we actually use.
+        """
+        return {
+            "origin": "developername",
+            "last_updated": None,
+            "package_name": snap_name,
+            "screenshot_url": None,
+            "developer_id": "46MtBuBZaWy3g8picgdg6YkrCQo84J46",
+            "ratings_average": 0.0,
+            "title": "snap title here",
+            "support_url": "",
+            "icon_url": None,
+            "developer_name": "developername",
+            "screenshot_urls": [],
+            "description": "Description of the most simple snap",
+            "price": 0.0,
+            "translations": {},
+            "prices": {},
+            "publisher": "some publisher",
+            "summary": "Summary of the most simple snap",
+        }
+
+
+class SnapIdent:
+    """A namespace for functions that generate well-known snapident payloads.
+
+    The functions on this class all return JSON-serializable objects that
+    can be set in the service mocks. The service mocks will ensure that they
+    meet the output validation of the service in question.
+    """
+
+    @staticmethod
+    def NoSuchSnap():
+        return SnapIdentBuilder().get_payload()
+
+    @staticmethod
+    def SingleSnap(snap_name=None, snap_id=None, series=None, authority=None,
+                   private=None, publisher_id=None, stores=None, status=None,
+                   country_blacklist=None, country_whitelist=None):
+        builder = SnapIdentBuilder()
+        builder.add_snap(
+            snap_name=snap_name,
+            snap_id=snap_id,
+            series=series,
+            authority=authority,
+            private=private,
+            publisher_id=publisher_id,
+            stores=stores,
+            status=status,
+            country_blacklist=country_blacklist,
+            country_whitelist=country_whitelist,
+        )
+        return builder.get_payload()
+
+
+class SnapFind:
+    """A namespace for functions that generate well-known snapfind payloads.
+
+    The functions on this class all return JSON-serializable objects that
+    can be set in the service mocks. The service mocks will ensure that they
+    meet the output validation of the service in question.
+    """
+
+    @staticmethod
+    def SnapSectionList(snap_sections):
+        return {
+            'sections': [
+                {
+                    'section_name': section_name,
+                    'snaps': [
+                        {
+                            'snap_id': snap_id,
+                            'series': '16',
+                            'featured': False,
+                            'score': 0,
+                        } for snap_id in snap_ids
+                    ],
+                } for section_name, snap_ids in snap_sections.items()]
+        }
+
+
+class SnapRevsBuilder:
+
+    def __init__(self):
+        self.revisions = []
+        self.channelmaps = []
+
+    def add_revision(self, snap_id, revision, **kwargs):
+        self.revisions.append({
+            'snap_id': snap_id,
+            'revision': revision,
+            # XXX snapd uses RFC3339, instead of 8601
+            'created_at': kwargs.get('created_at', '2017-01-01T00:00:00'),
+            'created_by': kwargs.get('created_by', 'developer_id_here'),
+            'architectures': kwargs.get('architectures', ['amd64']),
+            'binary_path': kwargs.get('binary_path', '/path/to.snap'),
+            'binary_filesize': kwargs.get('binary_filesize', 12345),
+            'binary_sha512': kwargs.get('binary_sha512', 'sha512-here'),
+            'binary_sha3_384': kwargs.get('binary_sha3_384', 'sha3384-here'),
+            'version': kwargs.get('version', '1.0'),
+            'confinement': kwargs.get('confinement', 'strict'),
+            'snap_yaml': kwargs.get('snap_yaml', ''),
+            'epoch': kwargs.get('epoch', 0),
+            'type': kwargs.get('type', 'app'),
+            'was_released': kwargs.get('was_released', False),
+            'is_released': kwargs.get('is_released', False),
+        })
+
+    def get_payload(self):
+        return {
+            'revisions': self.revisions,
+            'channelmaps': self.channelmaps,
+        }
+
+
+class SnapRevs():
+
+    @staticmethod
+    def NoRevisions():
+        return SnapRevsBuilder().get_payload()
+
+    @staticmethod
+    def SingleRevision(snap_id, revision, **kwargs):
+        builder = SnapRevsBuilder()
+        builder.add_revision(snap_id, revision, **kwargs)
+        # TODO: make the builder smarter about whether it should emit
+        # channelmaps or not:
+        return {'revisions': builder.get_payload()['revisions']}
diff --git a/snapstore_client/tests/test_webservices.py b/snapstore_client/tests/test_webservices.py
new file mode 100644
index 0000000..c31f16b
--- /dev/null
+++ b/snapstore_client/tests/test_webservices.py
@@ -0,0 +1,439 @@
+# Copyright 2017 Canonical Ltd.
+
+import base64
+import binascii
+import datetime
+import hashlib
+import json
+import sys
+import types
+from urllib.parse import urljoin
+
+from acceptable._doubles import set_service_locations
+import fixtures
+from requests.exceptions import HTTPError
+import responses
+from snapstore_schemas.service_doubles import (
+    snapfind,
+    snapident,
+    snaprevs,
+)
+from testtools import TestCase
+
+from snapstore_client import (
+    config,
+    webservices,
+)
+from snapstore_client.tests import factory
+
+if sys.version < '3.6':
+    import sha3  # noqa
+
+
+class NowFixture(fixtures.MonkeyPatch):
+
+    def __init__(self):
+        self.now = datetime.datetime.now()
+        super().__init__(
+            'datetime.datetime', types.SimpleNamespace(now=lambda: self.now))
+
+
+class WebservicesTests(TestCase):
+
+    def setUp(self):
+        super().setUp()
+        service_locations = config.read_config()['services']
+        set_service_locations(service_locations)
+
+    def test_get_snap_id_for_name_no_match(self):
+        self.useFixture(snapident.filter_snaps_1_0(
+            factory.SnapIdent.NoSuchSnap()))
+
+        self.assertIsNone(webservices.get_snap_id_for_name('mysnap', '16'))
+
+    def test_get_snap_id_for_name_match(self):
+        snap_name = 'mysnap'
+        snap_id = factory.generate_snap_id()
+        series = '16'
+        self.useFixture(snapident.filter_snaps_1_0(
+            factory.SnapIdent.SingleSnap(snap_name, snap_id, series=series)))
+
+        self.assertEqual(
+            snap_id, webservices.get_snap_id_for_name(snap_name, series))
+
+    def test_register_snap_name_and_blob_success(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        builder = factory.SnapIdentBuilder()
+        builder.add_snap()
+        snap = builder.get_payload()['snaps'][0]
+        snapident_fixture = self.useFixture(
+            snapident.update_snaps_1_0({'ok': True}))
+
+        self.assertFalse(webservices.register_snap_name_and_blob(
+            snap['snap_id'], snap['snap_name'], snap['series'], snap['blob'],
+            authority=snap['authority']))
+        snapident_request = snapident_fixture.calls[0].request
+        self.assertEqual({
+            'snaps': [
+                {
+                    'snap_id': snap['snap_id'],
+                    'private': False,
+                    'publisher_id': snap['blob']['developer_id'],
+                    'snap_name': snap['snap_name'],
+                    'series': snap['series'],
+                    'blob': snap['blob'],
+                    'authority': snap['authority'],
+                    'status': 'published',
+                    'stores': ['ubuntu'],
+                },
+            ],
+        }, json.loads(snapident_request.body.decode()))
+        self.assertNotIn('Failed to register snap:', logger.output)
+
+    @responses.activate
+    def test_register_snap_name_and_blob_error(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        builder = factory.SnapIdentBuilder()
+        builder.add_snap()
+        snap = builder.get_payload()['snaps'][0]
+        update_snaps_url = urljoin(
+            config.read_config()['services']['snapident'], '/snaps/update')
+        responses.add(
+            'POST', update_snaps_url, status=400,
+            json=factory.APIError.single('Something went wrong').to_dict())
+
+        self.assertTrue(webservices.register_snap_name_and_blob(
+            snap['snap_id'], snap['snap_name'], snap['series'], snap['blob'],
+            authority=snap['authority']))
+        self.assertEqual(
+            'Failed to register snap:\nSomething went wrong\n', logger.output)
+
+    def test_release_revision_success(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        snap_name = 'mysnap'
+        snap_id = factory.generate_snap_id()
+        series = '16'
+        channel = [None, 'edge', None]
+        arches = ['amd64', 'armhf']
+        revision = 1
+        snaprevs_fixture = self.useFixture(
+            snaprevs.update_channelmaps_1_0({'success': True}))
+
+        webservices.release_revision(
+            snap_id, snap_name, series, channel, arches, revision=revision)
+        snaprevs_request = snaprevs_fixture.calls[0].request
+        self.assertEqual({
+            'developer_id': 'wgrant',
+            'release_requests': [
+                {
+                    'snap_id': snap_id,
+                    'channel': channel,
+                    'architecture': arch,
+                    'series': series,
+                    'revision': revision,
+                } for arch in arches
+            ],
+        }, json.loads(snaprevs_request.body.decode()))
+        self.assertNotIn('Failed to release revision:', logger.output)
+
+    @responses.activate
+    def test_release_revision_error(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        update_channelmaps_url = urljoin(
+            config.read_config()['services']['snaprevs'],
+            '/channelmaps/update')
+        responses.add(
+            'POST', update_channelmaps_url, status=400,
+            json=factory.APIError.single('Something went wrong').to_dict())
+
+        webservices.release_revision(
+            factory.generate_snap_id(), 'mysnap', '16', [None, 'edge', None],
+            ['amd64', 'armhf'], revision=1)
+        self.assertEqual(
+            'Failed to release revision:\nSomething went wrong\n',
+            logger.output)
+
+    def test_get_latest_revision_for_snap_id_no_revisions(self):
+        snap_id = factory.generate_snap_id()
+        self.useFixture(
+            snaprevs.fetch_revisions_1_0(factory.SnapRevs.NoRevisions()))
+
+        self.assertIsNone(webservices.get_latest_revision_for_snap_id(snap_id))
+
+    def test_get_latest_revision_for_snap_id_revisions(self):
+        snap_id = factory.generate_snap_id()
+        builder = factory.SnapRevsBuilder()
+        builder.add_revision(snap_id, 1)
+        builder.add_revision(snap_id, 2)
+        self.useFixture(
+            snaprevs.fetch_revisions_1_0(
+                {'revisions': builder.get_payload()['revisions']}))
+
+        self.assertEqual(
+            2, webservices.get_latest_revision_for_snap_id(snap_id))
+
+    def test_create_revision_success(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        now_fixture = self.useFixture(NowFixture())
+        snap_id = factory.generate_snap_id()
+        snaprevs_fixture = self.useFixture(
+            snaprevs.create_revisions_1_0(
+                {'num_revisions_created': 1}, output_status=201))
+
+        self.assertTrue(webservices.create_revision(
+            snap_id, 1, ['amd64'], '/path/to/blob.snap', 4096,
+            hashlib.sha512(b'blob').hexdigest(),
+            hashlib.sha3_384(b'blob').hexdigest(),
+            '1.0', 'strict', 'name: blob\n'))
+        snaprevs_request = snaprevs_fixture.calls[0].request
+        self.assertEqual([
+            {
+                'snap_id': snap_id,
+                'revision': 1,
+                'created_at': now_fixture.now.isoformat(),
+                'created_by': 'TODO',
+                'architectures': ['amd64'],
+                'binary_path': '/path/to/blob.snap',
+                'binary_filesize': 4096,
+                'binary_sha512': hashlib.sha512(b'blob').hexdigest(),
+                'binary_sha3_384': hashlib.sha3_384(b'blob').hexdigest(),
+                'version': '1.0',
+                'confinement': 'strict',
+                'snap_yaml': 'name: blob\n',
+                'epoch': 0,
+                'type': 'app',
+            },
+        ], json.loads(snaprevs_request.body.decode()))
+        self.assertNotIn('Failed to create revision:', logger.output)
+
+    @responses.activate
+    def test_create_revision_error(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        snap_id = factory.generate_snap_id()
+        create_revisions_url = urljoin(
+            config.read_config()['services']['snaprevs'], '/revisions/create')
+        responses.add(
+            'POST', create_revisions_url, status=400,
+            json=factory.APIError.single('Something went wrong').to_dict())
+
+        self.assertFalse(webservices.create_revision(
+            snap_id, 1, ['amd64'], '/path/to/blob.snap', 4096,
+            hashlib.sha512(b'blob').hexdigest(),
+            hashlib.sha3_384(b'blob').hexdigest(),
+            '1.0', 'strict', 'name: blob\n'))
+        self.assertEqual(
+            'Failed to create revision:\nSomething went wrong\n',
+            logger.output)
+
+    def test_create_snapsections_success(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        snapfind_fixture = self.useFixture(
+            snapfind.update_snap_section_1_0({'ok': True}))
+
+        snap_sections = factory.SnapFind.SnapSectionList({
+            'section1': [factory.generate_snap_id()],
+            'section2': [factory.generate_snap_id()],
+        })
+        webservices.create_snapsections(snap_sections)
+        snapfind_request = snapfind_fixture.calls[0].request
+        self.assertEqual(
+            snap_sections, json.loads(snapfind_request.body.decode()))
+        self.assertEqual(
+            'Updating sections and snapsections...\nDone.\n', logger.output)
+
+    @responses.activate
+    def test_create_snapsections_error(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        update_snap_section_url = urljoin(
+            config.read_config()['services']['snapfind'], '/sections/snaps')
+        responses.add(
+            'POST', update_snap_section_url, status=400,
+            json=factory.APIError.single('Something went wrong').to_dict())
+
+        webservices.create_snapsections({})
+        self.assertEqual(
+            'Updating sections and snapsections...\n'
+            'Failed to update sections:\nSomething went wrong\n',
+            logger.output)
+
+    @responses.activate
+    def test_get_assertion_success(self):
+        assertions_root = config.read_config()['services']['assertions']
+        get_assertions_url = urljoin(
+            assertions_root, 'assertions/snap-revision/dummy')
+        responses.add(
+            'GET', get_assertions_url, status=200, body='Dummy assertion\n')
+
+        self.assertEqual(
+            b'Dummy assertion\n',
+            webservices.get_assertion(
+                assertions_root, 'snap-revision', ['dummy']))
+
+    @responses.activate
+    def test_get_assertion_error(self):
+        assertions_root = config.read_config()['services']['assertions']
+        get_assertions_url = urljoin(
+            assertions_root, 'assertions/snap-revision/dummy')
+        responses.add('GET', get_assertions_url, status=400)
+
+        self.assertIsNone(webservices.get_assertion(
+            assertions_root, 'snap-revision', ['dummy']))
+
+    @responses.activate
+    def test_create_or_update_assertions_no_snap_declaration(self):
+        now_fixture = self.useFixture(NowFixture())
+        assertions_root = config.read_config()['services']['assertions']
+        authority = config.read_config()['assertions']['authority']
+        snap_id = factory.generate_snap_id()
+        binary_sha3_384 = hashlib.sha3_384(b'blob').hexdigest()
+        snap_sha3_384 = base64.urlsafe_b64encode(
+            binascii.a2b_hex(binary_sha3_384)).decode().rstrip('=')
+        get_assertions_url = urljoin(
+            assertions_root,
+            'assertions/snap-declaration/16/{}'.format(snap_id))
+        sign_assertions_url = urljoin(assertions_root, 'sign')
+        save_assertions_url = urljoin(assertions_root, 'assertions')
+        responses.add('GET', get_assertions_url, status=404)
+        signed_assertions_iter = iter([
+            (200, {}, 'Dummy snap-declaration assertion\n'),
+            (200, {}, 'Dummy snap-revision assertion\n'),
+        ])
+        responses.add_callback(
+            'POST', sign_assertions_url,
+            callback=lambda _: next(signed_assertions_iter))
+        responses.add('POST', save_assertions_url, status=201)
+
+        webservices.create_or_update_assertions(
+            snap_id, 'mysnap', '16', 1, binary_sha3_384, 4096)
+        (_, declaration_sign_request, declaration_save_request,
+         revision_sign_request, revision_save_request) = [
+            call.request for call in responses.calls]
+        self.assertEqual({
+            'key-id': config.read_config()['assertions']['signing_key_id'],
+            'headers': {
+                'type': 'snap-declaration',
+                'revision': '0',
+                'authority-id': authority,
+                'publisher-id': authority,
+                'series': '16',
+                'snap-id': snap_id,
+                'snap-name': 'mysnap',
+                'timestamp': now_fixture.now.isoformat() + 'Z',
+            },
+        }, json.loads(declaration_sign_request.body.decode()))
+        self.assertEqual(
+            'Dummy snap-declaration assertion\n',
+            declaration_save_request.body)
+        self.assertEqual({
+            'key-id': config.read_config()['assertions']['signing_key_id'],
+            'headers': {
+                'type': 'snap-revision',
+                'authority-id': authority,
+                'developer-id': authority,
+                'snap-sha3-384': snap_sha3_384,
+                'snap-id': snap_id,
+                'snap-size': '4096',
+                'snap-revision': '1',
+                'timestamp': now_fixture.now.isoformat() + 'Z',
+            },
+        }, json.loads(revision_sign_request.body.decode()))
+        self.assertEqual(
+            'Dummy snap-revision assertion\n', revision_save_request.body)
+
+    @responses.activate
+    def test_create_or_update_assertions_with_snap_declaration(self):
+        now_fixture = self.useFixture(NowFixture())
+        assertions_root = config.read_config()['services']['assertions']
+        authority = config.read_config()['assertions']['authority']
+        snap_id = factory.generate_snap_id()
+        binary_sha3_384 = hashlib.sha3_384(b'blob').hexdigest()
+        snap_sha3_384 = base64.urlsafe_b64encode(
+            binascii.a2b_hex(binary_sha3_384)).decode().rstrip('=')
+        get_assertions_url = urljoin(
+            assertions_root,
+            'assertions/snap-declaration/16/{}'.format(snap_id))
+        sign_assertions_url = urljoin(assertions_root, 'sign')
+        save_assertions_url = urljoin(assertions_root, 'assertions')
+        responses.add(
+            'GET', get_assertions_url, status=200,
+            body='Dummy snap-declaration assertion\n')
+        responses.add(
+            'POST', sign_assertions_url, status=200,
+            body='Dummy snap-revision assertion\n')
+        responses.add('POST', save_assertions_url, status=201)
+
+        webservices.create_or_update_assertions(
+            snap_id, 'mysnap', '16', 1, binary_sha3_384, 4096)
+        _, sign_request, save_request = [
+            call.request for call in responses.calls]
+        self.assertEqual({
+            'key-id': config.read_config()['assertions']['signing_key_id'],
+            'headers': {
+                'type': 'snap-revision',
+                'authority-id': authority,
+                'developer-id': authority,
+                'snap-sha3-384': snap_sha3_384,
+                'snap-id': snap_id,
+                'snap-size': '4096',
+                'snap-revision': '1',
+                'timestamp': now_fixture.now.isoformat() + 'Z',
+            },
+        }, json.loads(sign_request.body.decode()))
+
+    @responses.activate
+    def test_save_assertion_success(self):
+        assertions_root = config.read_config()['services']['assertions']
+        save_assertions_url = urljoin(assertions_root, 'assertions')
+        responses.add('POST', save_assertions_url, status=201)
+
+        webservices.save_assertion('Dummy assertion\n')
+        request = responses.calls[0].request
+        self.assertEqual(
+            'application/x.ubuntu.assertion', request.headers['Content-Type'])
+        self.assertEqual('Dummy assertion\n', request.body)
+
+    @responses.activate
+    def test_save_assertion_error(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        assertions_root = config.read_config()['services']['assertions']
+        save_assertions_url = urljoin(assertions_root, 'assertions')
+        responses.add(
+            'POST', save_assertions_url, status=400,
+            json=factory.APIError.single('Something went wrong').to_dict())
+
+        self.assertRaises(
+            HTTPError, webservices.save_assertion, 'Dummy assertion\n')
+        self.assertEqual(
+            'Failed to save assertion:\nSomething went wrong\n',
+            logger.output)
+
+    @responses.activate
+    def test_sign_assertion_success(self):
+        assertions_root = config.read_config()['services']['assertions']
+        sign_assertions_url = urljoin(assertions_root, 'sign')
+        responses.add(
+            'POST', sign_assertions_url, status=200, body='Dummy assertion\n')
+
+        self.assertEqual(
+            'Dummy assertion\n', webservices.sign_assertion({'revision': 1}))
+        request = responses.calls[0].request
+        self.assertEqual('application/json', request.headers['Content-Type'])
+        self.assertEqual({
+            'key-id': config.read_config()['assertions']['signing_key_id'],
+            'headers': {'revision': 1},
+        }, json.loads(request.body.decode()))
+
+    @responses.activate
+    def test_sign_assertion_error(self):
+        logger = self.useFixture(fixtures.FakeLogger())
+        assertions_root = config.read_config()['services']['assertions']
+        sign_assertions_url = urljoin(assertions_root, 'sign')
+        responses.add(
+            'POST', sign_assertions_url, status=400,
+            json=factory.APIError.single('Something went wrong').to_dict())
+
+        self.assertRaises(
+            HTTPError, webservices.sign_assertion, {'revision': 1})
+        self.assertEqual(
+            'Failed to sign assertion:\nSomething went wrong\n',
+            logger.output)
diff --git a/snapstore_client/webservices.py b/snapstore_client/webservices.py
index 4c5e234..43e122c 100644
--- a/snapstore_client/webservices.py
+++ b/snapstore_client/webservices.py
@@ -126,7 +126,7 @@ def create_revision(snap_id, revision, architectures, binary_path, filesize,
                     sha512, sha3_384, version, confinement, snap_yaml):
     """Create a snap revision with snaprevs.
 
-    Returns True on succcess, False otherwise.
+    Returns True on success, False otherwise.
     """
     snaprevs_root = config.read_config()['services']['snaprevs']
     # TODO: I suspect this is supposed to be UTC time, not local time?
@@ -172,7 +172,7 @@ def create_snapsections(payload):
     if response.ok:
         logger.info('Done.')
     else:
-        logger.error(response.text)
+        _print_error_message('update sections', response)
 
 
 def get_assertion(root, type_, key):