Merge lp:~ricardokirkner/ols-store-tests/more-acceptance-tests into lp:~ubuntuone-pqm-team/ols-store-tests/store-acceptance-tests

[Ricardo Kirkner]

added basic smoke tests for cpi APIs

added tests for following endpoints:

- package
- click metadata
- snap metadata
- highlights
- frameworks
- departments
- channels

[lp:~ricardokirkner/ols-store-tests/more-acceptance-tests]

25. By Ricardo Kirkner on 2016-07-06

refactor tests to use constant

[Matias Bordese (matiasb)]

Looking good, added a few comments/questions.

review: Approve

[lp:~ricardokirkner/ols-store-tests/more-acceptance-tests]

26. By Ricardo Kirkner on 2016-07-07

fixes per review

[James Tait (jamestait)]

Yep, looks good to me. I've made a couple of suggestions, but they are just that - this is good to land as-is, IMO.

As an aside, we're hard-coding some assumptions about URL structure (e.g. appending click-package-name or snap-package-id to /api/v1/package), which may not hold true longer-term. I think that's probably OK for these tests, since we *want* to know if URLs change, and I don't think *any* of the clients are actually parsing the links from the root resource anyway.

review: Approve

[lp:~ricardokirkner/ols-store-tests/more-acceptance-tests]

27. By Ricardo Kirkner on 2016-07-07

fixes per review

=== modified file 'Makefile'
--- Makefile	2016-07-05 14:42:00 +0000
+++ Makefile	2016-07-07 18:53:29 +0000
@@ -3,7 +3,7 @@
 PYTHON = python3
 VM = store-acceptance-tests
 VSSH = ols-vms shell ${VM}
-TEST_TARGET := discover tests/api
+TEST_TARGET ?= discover tests/api
 
 vm-setup: ols-vms.conf
 	if [ `ols-vms status ${VM}` = 'RUNNING' ] ; then ols-vms stop ${VM} ; fi
 
=== modified file 'tests/api/cpi/helpers.py'
--- tests/api/cpi/helpers.py	2016-06-28 19:20:09 +0000
+++ tests/api/cpi/helpers.py	2016-07-07 18:53:29 +0000
@@ -1,14 +1,52 @@
+import getpass
 import os
 import unittest
 
 
 CPI_ROOT_URL = os.getenv(
     'CPI_ROOT_URL', 'https://search.apps.staging.ubuntu.com')
+SSO_ROOT_URL = os.getenv(
+    'SSO_ROOT_URL', 'https://login.staging.ubuntu.com')
+
+TEST_USER_EMAIL = os.getenv('TEST_USER_EMAIL', None)
+if TEST_USER_EMAIL is None:
+    TEST_USER_EMAIL = input('Test user email: ')
+TEST_USER_PASSWORD = os.getenv('TEST_USER_PASSWORD', None)
+if TEST_USER_PASSWORD is None:
+    TEST_USER_PASSWORD = getpass.getpass('Test user password: ')
+
+CLICK_PACKAGE_NAME = 'demo37.ricardokirkner'
+SNAP_PACKAGE_NAME = 'hello-world'
+SNAP_PACKAGE_CHANNEL = 'stable'
+SNAP_PACKAGE_REVISION = 6
+SNAP_PACKAGE_SNAP_ID = 'JtwEnisYi8Mmk51vNLZPSOwSOFLwGdhs'
+PRIVATE_SNAP_PACKAGE_NAME = 'ricardokirkner-test1'
+PRIVATE_SNAP_PACKAGE_SNAP_ID = 'qrwoXeYOXAZla2ga3XtBSogV1vAUKqZh'
+PRIVATE_SNAP_PACKAGE_CHANNEL = 'stable'
+PRIVATE_SNAP_PACKAGE_REVISION = 1
 
 
 class APITestCase(unittest.TestCase):
 
-    def assert_success(self, response):
+    def assert_success(self, response, content_type='application/hal+json'):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.headers['Content-Type'],
-                         'application/hal+json')
+                         content_type)
+
+    def assert_not_found(self, response, message=None):
+        self.assertEqual(response.status_code, 404)
+        self.assertEqual(response.headers['Content-Type'],
+                         'application/hal+json')
+        self.assertEqual(response.json(), {
+            'result': 'error',
+            'errors': [message or 'Not found'],
+        })
+
+    def assert_bad_request(self, response, message):
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.headers['Content-Type'],
+                         'application/hal+json')
+        self.assertEqual(response.json(), {
+            'result': 'error',
+            'errors': [message],
+        })
 
=== added file 'tests/api/cpi/test_channel.py'
--- tests/api/cpi/test_channel.py	1970-01-01 00:00:00 +0000
+++ tests/api/cpi/test_channel.py	2016-07-07 18:53:29 +0000
@@ -0,0 +1,56 @@
+import requests
+
+from .helpers import (
+    CPI_ROOT_URL,
+    APITestCase,
+)
+
+
+def get_channels():
+    url = '{}/api/v1/channels'.format(CPI_ROOT_URL)
+    response = requests.get(url)
+    return response
+
+
+def get_channel(name):
+    url = '{}/api/v1/channels/{}'.format(CPI_ROOT_URL, name)
+    response = requests.get(url)
+    return response
+
+
+class ChannelsTestCase(APITestCase):
+
+    def assert_channels(self, response):
+        body = response.json()
+        # assert generic embedded data structure
+        self.assertIn('_embedded', body)
+        self.assertIn('clickindex:channel', body['_embedded'])
+        # assert there is at least one result
+        self.assertGreater(len(body['_embedded']['clickindex:channel']), 0)
+        # assert result data structure
+        channel_data = body['_embedded']['clickindex:channel']
+        channel_names = ('stable', 'candidate', 'beta', 'edge')
+        for item, name in zip(channel_data, channel_names):
+            self._assert_channel_data(item, name=name)
+
+    def assert_channel(self, response, name):
+        body = response.json()
+        # assert result data structure
+        self._assert_channel_data(body, name=name)
+
+    def _assert_channel_data(self, data, name=None):
+        self.assertIn('promotion_order', data)
+        self.assertIn('display_name', data)
+        self.assertIn('name', data)
+        if name is not None:
+            self.assertEqual(data['name'], name)
+
+    def test_get_channels(self):
+        response = get_channels()
+        self.assert_success(response)
+        self.assert_channels(response)
+
+    def test_get_channel(self):
+        response = get_channel('edge')
+        self.assert_success(response)
+        self.assert_channel(response, 'edge')
 
=== added file 'tests/api/cpi/test_department.py'
--- tests/api/cpi/test_department.py	1970-01-01 00:00:00 +0000
+++ tests/api/cpi/test_department.py	2016-07-07 18:53:29 +0000
@@ -0,0 +1,82 @@
+import requests
+
+from .helpers import (
+    CPI_ROOT_URL,
+    APITestCase,
+)
+
+
+def get_departments(include_subdepartments=None):
+    url = '{}/api/v1/departments'.format(CPI_ROOT_URL)
+    if include_subdepartments is True:
+        url += '?include_subdepartments=true'
+    elif include_subdepartments is False:
+        url += '?include_subdepartments=false'
+    response = requests.get(url)
+    return response
+
+
+def get_department(slug):
+    url = '{}/api/v1/departments/{}'.format(CPI_ROOT_URL, slug)
+    response = requests.get(url)
+    return response
+
+
+class DepartmentsTestCase(APITestCase):
+
+    def assert_departments(self, response):
+        body = response.json()
+        # assert generic embedded data structure
+        self.assertIn('_embedded', body)
+        self.assertIn('clickindex:department', body['_embedded'])
+        # assert there is at least one result
+        self.assertGreater(len(body['_embedded']['clickindex:department']), 0)
+        # assert result data structure
+        item = body['_embedded']['clickindex:department'][0]
+        self._assert_department_data(item)
+
+    def assert_department(self, response, slug):
+        body = response.json()
+        # assert result data structure
+        self._assert_department_data(body, slug=slug)
+
+    def _assert_department_data(self, data, slug=None):
+        self.assertIn('has_children', data)
+        self.assertIn('name', data)
+        self.assertIn('slug', data)
+        if slug is not None:
+            self.assertEqual(data['slug'], slug)
+
+    def find_subdepartment(self, response, department, slug):
+        body = response.json()
+        for item in body.get('_embedded', {}).get('clickindex:department', []):
+            department_match = item.get('slug') == department
+            if department_match and item.get('has_children', False):
+                for subitem in item.get('_embedded', {}).get(
+                        'clickindex:department', []):
+                    if subitem.get('slug') == slug:
+                        return subitem
+
+    def test_get_departments(self):
+        response = get_departments()
+        self.assert_success(response)
+        self.assert_departments(response)
+
+    def test_get_department(self):
+        response = get_department(slug='games')
+        self.assert_success(response)
+        self.assert_department(response, slug='games')
+
+    def test_include_subdepartments_by_default(self):
+        response = get_departments()
+        self.assert_success(response)
+        department = self.find_subdepartment(
+            response, 'games', slug='fps')
+        self.assertIsNotNone(department)
+        self._assert_department_data(department, slug='fps')
+
+    def test_exclude_subdepartments(self):
+        response = get_departments(include_subdepartments=False)
+        self.assert_success(response)
+        department = self.find_subdepartment(response, 'games', slug='fps')
+        self.assertIsNone(department)
 
=== added file 'tests/api/cpi/test_framework.py'
--- tests/api/cpi/test_framework.py	1970-01-01 00:00:00 +0000
+++ tests/api/cpi/test_framework.py	2016-07-07 18:53:29 +0000
@@ -0,0 +1,60 @@
+import requests
+
+from .helpers import (
+    CPI_ROOT_URL,
+    APITestCase,
+)
+
+
+def get_frameworks():
+    url = '{}/api/v1/frameworks'.format(CPI_ROOT_URL)
+    response = requests.get(url)
+    return response
+
+
+def get_framework(name):
+    url = '{}/api/v1/frameworks/{}'.format(CPI_ROOT_URL, name)
+    response = requests.get(url)
+    return response
+
+
+class FrameworksTestCase(APITestCase):
+
+    def assert_frameworks(self, response):
+        body = response.json()
+        # assert generic embedded data structure
+        self.assertIn('_embedded', body)
+        self.assertIn('clickindex:framework', body['_embedded'])
+        # assert there is at least one result
+        self.assertGreater(len(body['_embedded']['clickindex:framework']), 0)
+        # assert result data structure
+        item = body['_embedded']['clickindex:framework'][0]
+        self._assert_framework_data(item)
+
+    def assert_framework(self, response, name):
+        body = response.json()
+        # assert result data structure
+        self._assert_framework_data(body, name=name)
+
+    def _assert_framework_data(self, data, name=None):
+        self.assertIn('enable_unauthenticated_downloads', data)
+        self.assertIn('policy_vendor', data)
+        self.assertIn('policy_version', data)
+        self.assertIn('state', data)
+        self.assertIn('name', data)
+        if name is not None:
+            self.assertEqual(data['name'], name)
+
+    def test_get_frameworks(self):
+        response = get_frameworks()
+        self.assert_success(response)
+        self.assert_frameworks(response)
+
+    def test_get_framework(self):
+        response = get_framework(name='ubuntu-sdk-15.04')
+        self.assert_success(response)
+        self.assert_framework(response, name='ubuntu-sdk-15.04')
+
+    def test_get_framework_not_found(self):
+        response = get_framework(name='invalid')
+        self.assert_not_found(response, message='No such framework')
 
=== added file 'tests/api/cpi/test_highlight.py'
--- tests/api/cpi/test_highlight.py	1970-01-01 00:00:00 +0000
+++ tests/api/cpi/test_highlight.py	2016-07-07 18:53:29 +0000
@@ -0,0 +1,65 @@
+import requests
+
+from .helpers import (
+    CPI_ROOT_URL,
+    APITestCase,
+)
+
+
+def get_highlights():
+    url = '{}/api/v1/highlights'.format(CPI_ROOT_URL)
+    response = requests.get(url)
+    return response
+
+
+def get_highlight(slug):
+    url = '{}/api/v1/highlights/{}'.format(CPI_ROOT_URL, slug)
+    response = requests.get(url)
+    return response
+
+
+class HighlightsTestCase(APITestCase):
+
+    def assert_highlights(self, response):
+        body = response.json()
+        # assert generic embedded data structure
+        self.assertIn('_embedded', body)
+        self.assertIn('clickindex:highlight', body['_embedded'])
+        # assert there is at least one result
+        self.assertGreater(len(body['_embedded']['clickindex:highlight']), 0)
+        # assert result data structure
+        item = body['_embedded']['clickindex:highlight'][0]
+        self._assert_highlight_data(item)
+
+    def assert_highlight(self, response, slug):
+        body = response.json()
+        # assert result data structure
+        self._assert_highlight_data(body, slug=slug)
+
+    def _assert_highlight_data(self, data, slug=None):
+        self.assertIn('name', data)
+        self.assertIn('description', data)
+        self.assertIn('country_code', data)
+        self.assertIn('slug', data)
+        if slug is not None:
+            self.assertEqual(data['slug'], slug)
+
+    def test_get_highlights(self):
+        response = get_highlights()
+        self.assert_success(response)
+        self.assert_highlights(response)
+
+    def test_get_highlight(self):
+        response = get_highlight(slug='top-apps')
+        self.assert_success(response)
+        self.assert_highlight(response, slug='top-apps')
+
+    def test_get_highlight_not_found(self):
+        response = get_highlight(slug='missing')
+        self.assert_not_found(
+            response, message="No such highlight u'missing'")
+
+    def test_get_highlight_invalid_slug(self):
+        response = get_highlight(slug='top-apps:en')
+        self.assert_not_found(
+            response, message="No such highlight u'top-apps:en'")
 
=== added file 'tests/api/cpi/test_metadata.py'
--- tests/api/cpi/test_metadata.py	1970-01-01 00:00:00 +0000
+++ tests/api/cpi/test_metadata.py	2016-07-07 18:53:29 +0000
@@ -0,0 +1,176 @@
+import json
+
+import requests
+
+from .helpers import (
+    CLICK_PACKAGE_NAME,
+    CPI_ROOT_URL,
+    SNAP_PACKAGE_SNAP_ID,
+    APITestCase,
+)
+
+
+def get_click_metadata(names=None, method='get'):
+    url = '{}/api/v1/click-metadata'.format(CPI_ROOT_URL)
+    if method == 'get':
+        if names is not None:
+            url += '?' + '&'.join('name=' + name for name in names)
+        response = requests.get(url)
+    elif method == 'post':
+        data = {}
+        if names is not None:
+            data['name'] = names
+        response = requests.post(url, data=json.dumps(data),
+                                 headers={'Content-Type': 'application/json'})
+    else:
+        raise ValueError('invalid method: %s' % method)
+    return response
+
+
+class ClickMetadataTestCase(APITestCase):
+
+    def assert_click_metadata(self, response, name):
+        body = response.json()
+        self.assertEqual(len(body), 1)
+        # assert result data structure
+        self._assert_package_data(body[0], name=name)
+
+    def _assert_package_data(self, data, name):
+        self.assertIn('anon_download_url', data)
+        self.assertIn('binary_filesize', data)
+        self.assertIn('changelog', data)
+        self.assertIn('channel', data)
+        self.assertIn('content', data)
+        self.assertIn('department', data)
+        self.assertIn('download_sha512', data)
+        self.assertIn('download_url', data)
+        self.assertIn('icon_url', data)
+        self.assertIn('name', data)
+        self.assertIn('origin', data)
+        self.assertIn('revision', data)
+        self.assertIn('status', data)
+        self.assertIn('summary', data)
+        self.assertIn('title', data)
+        self.assertIn('version', data)
+        self.assertEqual(data['name'], name)
+
+    def test_get_click_metadata(self):
+        response = get_click_metadata(names=[CLICK_PACKAGE_NAME])
+        self.assert_success(response, content_type='application/json')
+        self.assert_click_metadata(response, name=CLICK_PACKAGE_NAME)
+
+    def test_get_click_metadata_no_packages(self):
+        response = get_click_metadata()
+        self.assert_bad_request(
+            response,
+            message='Package names must be specified in parameter "name".')
+
+    def test_get_click_metadata_via_post(self):
+        response = get_click_metadata(
+            names=[CLICK_PACKAGE_NAME], method='post')
+        self.assert_success(response, content_type='application/json')
+        self.assert_click_metadata(response, name=CLICK_PACKAGE_NAME)
+
+    def test_get_click_metadata_no_packages_via_post(self):
+        response = get_click_metadata(method='post')
+        self.assert_bad_request(
+            response,
+            message='Package names must be specified in parameter "name".')
+
+    def test_get_click_metadata_bad_request_via_post(self):
+        url = '{}/api/v1/click-metadata'.format(CPI_ROOT_URL)
+        response = requests.post(url, data='invalid data',
+                                 headers={'Content-Type': 'application/json'})
+        self.assert_bad_request(
+            response, message='No JSON object could be decoded')
+
+
+def get_metadata(snaps=None, fields=None):
+    url = '{}/api/v1/metadata'.format(CPI_ROOT_URL)
+    data = {}
+    if snaps is not None:
+        data['snaps'] = snaps
+    if fields is not None:
+        data['fields'] = fields
+    response = requests.post(url, data=json.dumps(data),
+                             headers={'Content-Type': 'application/json'})
+    return response
+
+
+class MetadataTestCase(APITestCase):
+
+    def assert_metadata(self, response, fields=None, snap_id=None):
+        body = response.json()
+        # assert generic embedded data structure
+        self.assertIn('_embedded', body)
+        self.assertIn('clickindex:package', body['_embedded'])
+        # assert there is at least one result
+        self.assertGreater(len(body['_embedded']['clickindex:package']), 0)
+        # assert result data structure
+        item = body['_embedded']['clickindex:package'][0]
+        self._assert_package_data(item, fields=fields, snap_id=snap_id)
+
+    def _assert_package_data(self, data, fields=None, snap_id=None):
+        if fields is None:
+            fields = [
+                'anon_download_url',
+                'binary_filesize',
+                'changelog',
+                'channel',
+                'content',
+                'department',
+                'download_sha512',
+                'download_url',
+                'icon_url',
+                'name',
+                'origin',
+                'package_name',
+                'plugs',
+                'revision',
+                'slots',
+                'snap_id',
+                'status',
+                'summary',
+                'title',
+                'version',
+            ]
+        expected = fields + ['_links']
+        self.assertEqual(set(data.keys()), set(expected))
+        if snap_id is not None:
+            self.assertEqual(data['snap_id'], snap_id)
+
+    def assert_no_results(self, response):
+        body = response.json()
+        self._assert_package_data(body, fields=[])
+
+    def test_get_metadata(self):
+        response = get_metadata(
+            snaps=[{'snap_id': SNAP_PACKAGE_SNAP_ID}])
+        self.assert_success(response)
+        self.assert_metadata(response, snap_id=SNAP_PACKAGE_SNAP_ID)
+
+    def test_get_metadata_no_snaps(self):
+        response = get_metadata()
+        self.assert_bad_request(
+            response,
+            message='Packages must be specified in parameter "snaps".')
+
+    def test_get_metadata_missing_snap_id(self):
+        response = get_metadata(snaps=[{}])
+        self.assert_bad_request(
+            response, message='Missing snap_id for snap.')
+
+    def test_get_metadata_filter_fields(self):
+        fields = ['channel', 'revision', 'snap_id']
+        response = get_metadata(
+            snaps=[{'snap_id': SNAP_PACKAGE_SNAP_ID}],
+            fields=fields)
+        self.assert_success(response)
+        self.assert_metadata(
+            response, fields=fields, snap_id=SNAP_PACKAGE_SNAP_ID)
+
+    def test_get_metadata_invalid_package(self):
+        response = get_metadata(
+            snaps=[{'snap_id': 'invalid'}])
+        self.assert_success(response)
+        self.assert_no_results(response)
 
=== added file 'tests/api/cpi/test_package.py'
--- tests/api/cpi/test_package.py	1970-01-01 00:00:00 +0000
+++ tests/api/cpi/test_package.py	2016-07-07 18:53:29 +0000
@@ -0,0 +1,225 @@
+import json
+
+import requests
+import requests_oauthlib
+
+from .helpers import (
+    CPI_ROOT_URL,
+    PRIVATE_SNAP_PACKAGE_CHANNEL,
+    PRIVATE_SNAP_PACKAGE_NAME,
+    PRIVATE_SNAP_PACKAGE_REVISION,
+    PRIVATE_SNAP_PACKAGE_SNAP_ID,
+    SNAP_PACKAGE_CHANNEL,
+    SNAP_PACKAGE_NAME,
+    SNAP_PACKAGE_REVISION,
+    SSO_ROOT_URL,
+    TEST_USER_EMAIL,
+    TEST_USER_PASSWORD,
+    APITestCase,
+)
+
+
+def get_package(package_id, channel=None, revision=None, auth=False):
+    url = '{}/api/v1/package/{}'.format(CPI_ROOT_URL, package_id)
+    if channel is not None:
+        url += '/{}'.format(channel)
+    elif revision is not None:
+        url += '/{}'.format(revision)
+    if auth:
+        # use client as contextmanager to ensure ssl socket is closed
+        # afterwards
+        with get_oauth_client() as client:
+            response = client.get(url)
+    else:
+        response = requests.get(url)
+    return response
+
+
+def get_oauth_token_data(email, password):
+    url = '{}/api/v2/tokens/oauth'.format(SSO_ROOT_URL)
+    data = {
+        'email': email,
+        'password': password,
+        'token_name': 'store-acceptance-tests',
+    }
+    headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+    }
+    response = requests.post(url, data=json.dumps(data), headers=headers)
+    assert response.ok, 'Failed to get oauth token: %r' % response.content
+
+    data = response.json()
+    return {
+        'client_key': data['consumer_key'],
+        'client_secret': data['consumer_secret'],
+        'resource_owner_key': data['token_key'],
+        'resource_owner_secret': data['token_secret'],
+    }
+
+
+def get_oauth_client():
+    credentials = get_oauth_token_data(TEST_USER_EMAIL, TEST_USER_PASSWORD)
+    client = requests_oauthlib.OAuth1Session(**credentials)
+    client.headers.update({
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-cache',
+    })
+    return client
+
+
+class PackageBaseTestCase(APITestCase):
+
+    def assert_package(self, response, snap_id=None, name=None,
+                       channel=None, revision=None, exclude_fields=None):
+        body = response.json()
+        fields = [
+            'alias',
+            'allow_unauthenticated',
+            'anon_download_url',
+            'architecture',
+            'binary_filesize',
+            'blacklist_country_codes',
+            'changelog',
+            'channel',
+            'channels',
+            'click_framework',
+            'click_version',
+            'company_name',
+            'confinement',
+            'content',
+            'date_published',
+            'department',
+            'description',
+            'developer_id',
+            'developer_name',
+            'download_sha512',
+            'download_url',
+            'epoch',
+            'framework',
+            'icon_url',
+            'icon_urls',
+            'id',
+            'is_published',
+            'keywords',
+            'last_updated',
+            'license',
+            'name',
+            'origin',
+            'package_name',
+            'plugs',
+            'price',
+            'prices',
+            'promoted',
+            'publisher',
+            'ratings_average',
+            'release',
+            'revision',
+            'screenshot_url',
+            'screenshot_urls',
+            'slots',
+            'snap_id',
+            'status',
+            'summary',
+            'support_url',
+            'terms_of_service',
+            'title',
+            'version',
+            'video_urls',
+            'website',
+            'whitelist_country_codes',
+        ]
+        # assert result data structure
+        expected = set(fields + ['_links'])
+        if exclude_fields:
+            expected = expected - set(exclude_fields)
+        self.assertEqual(set(body.keys()), expected)
+        if snap_id is not None:
+            self.assertEqual(body['snap_id'], snap_id)
+        if name is not None:
+            self.assertEqual(body['package_name'], name)
+        if channel is not None:
+            self.assertEqual(body['channel'], channel)
+            self.assertIn(channel, body['channels'])
+        if revision is not None:
+            self.assertEqual(body['revision'], revision)
+
+
+class PackageTestCase(PackageBaseTestCase):
+
+    def test_get_package(self):
+        response = get_package(SNAP_PACKAGE_NAME)
+        self.assert_success(response)
+        self.assert_package(response, name=SNAP_PACKAGE_NAME)
+
+    def test_get_private_package_when_not_authorized(self):
+        response = get_package(PRIVATE_SNAP_PACKAGE_SNAP_ID)
+        self.assert_not_found(response, message='No such package')
+
+    def test_get_private_package_when_authorized(self):
+        response = get_package(PRIVATE_SNAP_PACKAGE_SNAP_ID, auth=True)
+        self.assert_success(response)
+        self.assert_package(
+            response, snap_id=PRIVATE_SNAP_PACKAGE_SNAP_ID,
+            name=PRIVATE_SNAP_PACKAGE_NAME)
+
+    def test_get_package_not_found(self):
+        response = get_package('missing')
+        self.assert_not_found(response, message='No such package')
+
+
+class ChannelPackageTestCase(PackageBaseTestCase):
+
+    def test_get_channel_package(self):
+        response = get_package(SNAP_PACKAGE_NAME, channel=SNAP_PACKAGE_CHANNEL)
+        self.assert_success(response)
+        self.assert_package(response, name=SNAP_PACKAGE_NAME,
+                            channel=SNAP_PACKAGE_CHANNEL)
+
+    def test_get_private_channel_package_when_not_authorized(self):
+        response = get_package(PRIVATE_SNAP_PACKAGE_SNAP_ID,
+                               channel=PRIVATE_SNAP_PACKAGE_CHANNEL)
+        self.assert_not_found(response, message='No such package')
+
+    def test_get_private_channel_package_when_authorized(self):
+        response = get_package(PRIVATE_SNAP_PACKAGE_SNAP_ID,
+                               channel=PRIVATE_SNAP_PACKAGE_CHANNEL, auth=True)
+        self.assert_success(response)
+        self.assert_package(
+            response, snap_id=PRIVATE_SNAP_PACKAGE_SNAP_ID,
+            name=PRIVATE_SNAP_PACKAGE_NAME, channel=PRIVATE_SNAP_PACKAGE_CHANNEL)
+
+    def test_get_channel_package_not_found(self):
+        response = get_package('missing', channel='stable')
+        self.assert_not_found(response, message='No such package')
+
+    def test_get_channel_package_wrong_channel(self):
+        response = get_package(SNAP_PACKAGE_NAME, channel='missing')
+        self.assert_not_found(response, message='No such package')
+
+
+class PackageRevisionTestCase(PackageBaseTestCase):
+
+    def test_get_package_revision(self):
+        response = get_package(SNAP_PACKAGE_NAME, revision=SNAP_PACKAGE_REVISION)
+        self.assert_success(response)
+        self.assert_package(
+            response, name=SNAP_PACKAGE_NAME, revision=SNAP_PACKAGE_REVISION,
+            exclude_fields=['channel'])
+
+    def test_get_private_package_revision_when_not_authorized(self):
+        response = get_package(PRIVATE_SNAP_PACKAGE_SNAP_ID,
+                               revision=PRIVATE_SNAP_PACKAGE_REVISION)
+        self.assert_not_found(response, message='No such package')
+
+    def test_get_private_package_when_authorized(self):
+        response = get_package(PRIVATE_SNAP_PACKAGE_SNAP_ID,
+                               revision=PRIVATE_SNAP_PACKAGE_REVISION, auth=True)
+        self.assert_success(response)
+        self.assert_package(
+            response, snap_id=PRIVATE_SNAP_PACKAGE_SNAP_ID,
+            name=PRIVATE_SNAP_PACKAGE_NAME, exclude_fields=['channel'])
+
+    def test_get_package_revision_not_found(self):
+        response = get_package(SNAP_PACKAGE_NAME, revision=-1)
+        self.assert_not_found(response, message='No such package')