Merge lp:~jdstrand/click-reviewers-tools/lint-snapv2 into lp:click-reviewers-tools

[Jamie Strandboge]

add lint checks for snap.yaml
- add sr_lint.py. This adds complete snap.yaml checks. A few lint checks were dropped over cr_common.py, but these will be added in a future commit
- add clickreviews/tests/test_sr_lint.py which should provide full test coverage (coverage will be added in future commit)
- add bin/snap-check-lint
- update README for the above
- add coverage and coverage-report targets
- bin/click-review: make module sections more descriptive
- bin/click-review: rename click_fn variable as pkg_fn

Testing:
# click (same as prerequisite refactor branch)
PYTHONPATH=./ ./bin/click-review -v ../rottentomatoes/rottentomatoes.jdstrand_0.11.2_all.click | grep 'OK' |wc -l
120

# snap v1 (same as prerequisite refactor branch)
$ PYTHONPATH=./ ./bin/click-review -v ../ufw-trunk/ufw_0.35_all.snap | grep OK|wc -l
264

# snap v2 (these aren't all the tests since this is a simple snap, but does show the lint tests are being run)
$ PYTHONPATH=./ ./bin/click-review -v ../snappy-debug/snappy-debug_0.12_all.snap | grep OK|wc -l
26

[Jamie Strandboge (jdstrand)]

I implemented the remaining lint tests but need to update the testsuite.

[Jamie Strandboge (jdstrand)]

With r597, we should have complete snap.yaml checks and all missing TODOs checks are present. The lint checks are now on par with existing click and snap v1 checks. The testsuite covers all the checks and there is 100% coverage for these lint checks.

Next up, sr_security.py which will be in another MP.

[Daniel Holbach (dholbach)]

This by and large looks good to me. I'm no expert though on the specific checks required for snapv2 - would you like another review from somebody on the snappy team for this?

review: Approve

[Jamie Strandboge (jdstrand)]

I don't think that is required (they are quite busy)-- I'm going to run the tests through the existing snaps and I followed doc/meta.md for these. Anything that isn't right can just be a bug that I'll fix.

=== modified file '.bzrignore'
--- .bzrignore	2013-09-26 12:41:57 +0000
+++ .bzrignore	2016-02-11 18:32:45 +0000
@@ -9,3 +9,5 @@
 debian/click-reviewers-tools.substvars
 debian/files
 debian/tmp
+.coverage
+check-names.list.orig

=== modified file 'Makefile'
--- Makefile	2015-10-26 22:00:58 +0000
+++ Makefile	2016-02-11 18:32:45 +0000
@@ -7,6 +7,12 @@
 test:
 	./run-tests
 
+coverage:
+	python3 -m coverage run ./run-tests
+
+coverage-report:
+	python3 -m coverage report --show-missing --omit="*skeleton*,*/dist-packages/*"
+
 syntax-check: clean
 	./run-pyflakes
 	./run-pep8
@@ -23,6 +29,7 @@
 
 clean:
 	rm -rf ./clickreviews/__pycache__ ./clickreviews/tests/__pycache__
+	rm -rf ./.coverage
 
 .PHONY: check-names.list
 check-names.list:

=== modified file 'README'
--- README	2016-02-10 19:32:10 +0000
+++ README	2016-02-11 18:32:45 +0000
@@ -14,6 +14,7 @@
 - bin/click-run-checks: all tests
 
 Runnable snap v2 tests:
+- bin/snap-check-lint: lint tests
 - bin/snap-run-checks: all tests
 
 This gives an alternate view on bin/click-run-checks:

=== modified file 'bin/click-review'
--- bin/click-review	2016-02-09 21:45:25 +0000
+++ bin/click-review	2016-02-11 18:32:45 +0000
@@ -32,7 +32,7 @@
 
     def __init__(self, args):
         self.args = args
-        self.click_fn = self.args.filename
+        self.pkg_fn = self.args.filename
         self.modules = modules.get_modules()
 
     def _sumarise_results(self):
@@ -86,8 +86,9 @@
         #     review.do_checks()
         #     rc = review.do_report()
         #
-        section = module.replace('cr_', '')
-        review = modules.init_main_class(module, self.click_fn)
+        section = module.replace('cr_', 'click,snap.v1_')
+        section = section.replace('sr_', 'snap.v2_')
+        review = modules.init_main_class(module, self.pkg_fn)
         if review:
             review.do_checks()
             self.results[section] = review.click_report

=== added file 'bin/snap-check-lint'
--- bin/snap-check-lint	1970-01-01 00:00:00 +0000
+++ bin/snap-check-lint	2016-02-11 18:32:45 +0000
@@ -0,0 +1,24 @@
+#!/usr/bin/python3
+'''snap-check-lint: perform snap lint checks'''
+#
+# Copyright (C) 2013-2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
+
+import clickreviews.common as common
+import clickreviews.sr_lint as sr_lint
+
+if __name__ == "__main__":
+    common.run_check(sr_lint.SnapReviewLint)

=== modified file 'check-names.list'
--- check-names.list	2016-02-09 21:45:25 +0000
+++ check-names.list	2016-02-11 18:32:45 +0000
@@ -94,6 +94,69 @@
 lint:snappy_type_valid|
 lint:snappy_unknown|
 lint:snappy_version_valid|
+lint-snap-v2:apps|
+lint-snap-v2:apps_entry|
+lint-snap-v2:apps_present|
+lint-snap-v2:apps_required|
+lint-snap-v2:apps_unknown|
+lint-snap-v2:architecture_specified_needed|
+lint-snap-v2:architecture_valid|
+lint-snap-v2:attributes|
+lint-snap-v2:bus-name|
+lint-snap-v2:bus-name_framework|
+lint-snap-v2:bus-name|http://dbus.freedesktop.org/doc/dbus-specification.html
+lint-snap-v2:bus-name_matches_name|
+lint-snap-v2:command|
+lint-snap-v2:config_hook_executable|
+lint-snap-v2:daemon|
+lint-snap-v2:daemon_required|
+lint-snap-v2:description|
+lint-snap-v2:description_present|
+lint-snap-v2:external_symlinks|
+lint-snap-v2:frameworks|http://askubuntu.com/questions/460512/what-framework-should-i-use-in-my-manifest-file
+lint-snap-v2:icon_absolute_path|
+lint-snap-v2:icon_empty|
+lint-snap-v2:icon_exists|
+lint-snap-v2:icon_present|
+lint-snap-v2:is_squashfs|
+lint-snap-v2:license-agreement|
+lint-snap-v2:license-agreement_present|
+lint-snap-v2:license-version|
+lint-snap-v2:license-version_present|
+lint-snap-v2:listen-stream|
+lint-snap-v2:listen-stream_matches_name|
+lint-snap-v2:migration-skill|
+lint-snap-v2:name_valid|
+lint-snap-v2:nonexistent|
+lint-snap-v2:ports|
+lint-snap-v2:ports_ext1_format|
+lint-snap-v2:ports_ext2_format|
+lint-snap-v2:ports_int1_format|
+lint-snap-v2:ports_unknown_key|
+lint-snap-v2:ports_unknown_subkey|
+lint-snap-v2:poststop|
+lint-snap-v2:restart-condition|
+lint-snap-v2:snap_type_redflag|https://developer.ubuntu.com/en/snappy/guides/frameworks/
+lint-snap-v2:snap_type_valid|
+lint-snap-v2:socket|
+lint-snap-v2:socket-group|
+lint-snap-v2:socket-group_matches_name|
+lint-snap-v2:socket-group_reserved|
+lint-snap-v2:socket-user|
+lint-snap-v2:socket-user_matches_name|
+lint-snap-v2:socket-user_reserved|
+lint-snap-v2:stop|
+lint-snap-v2:stop-timeout|
+lint-snap-v2:stop-timeout_range|
+lint-snap-v2:summary|
+lint-snap-v2:summary_present|
+lint-snap-v2:type|
+lint-snap-v2:unknown_field|
+lint-snap-v2:uses|
+lint-snap-v2:uses_slot_reference|
+lint-snap-v2:valid_contents_for_architecture|
+lint-snap-v2:vcs_files|
+lint-snap-v2:version_valid|
 online_accounts:account-application_hook|
 online_accounts:account-application_id|
 online_accounts:account-application_root|

=== modified file 'clickreviews/common.py'
--- clickreviews/common.py	2016-02-09 21:45:25 +0000
+++ clickreviews/common.py	2016-02-11 18:32:45 +0000
@@ -33,6 +33,7 @@
 DEBUGGING = False
 UNPACK_DIR = None
 RAW_UNPACK_DIR = None
+MKSQUASHFS_OPTS = ['-noappend', '-comp', 'xz', '-all-root']
 
 
 def cleanup_unpack():
@@ -512,3 +513,91 @@
         recursive_rm(unpack_dir)
 
     return (pkgtype, pkgver)
+
+
+def find_external_symlinks(unpack_dir, pkg_files):
+    '''Check if symlinks in the package go out to the system.'''
+    common = '(-[0-9.]+)?\.so(\.[0-9.]+)?'
+    libc6_libs = ['ld-*.so',
+                  'libanl',
+                  'libBrokenLocale',
+                  'libc',
+                  'libcidn',
+                  'libcrypt',
+                  'libdl',
+                  'libmemusage',
+                  'libm',
+                  'libnsl',
+                  'libnss_compat',
+                  'libnss_dns',
+                  'libnss_files',
+                  'libnss_hesiod',
+                  'libnss_nisplus',
+                  'libnss_nis',
+                  'libpcprofile',
+                  'libpthread',
+                  'libresolv',
+                  'librt',
+                  'libSegFault',
+                  'libthread_db',
+                  'libutil',
+                  ]
+    libc6_pats = []
+    for lib in libc6_libs:
+        libc6_pats.append(re.compile(r'%s%s' % (lib, common)))
+    libc6_pats.append(re.compile(r'ld-*.so$'))
+    libc6_pats.append(re.compile(r'ld-linux-*.so\.[0-9.]+$'))
+
+    def _in_patterns(pats, f):
+        for pat in pats:
+            if pat.search(f):
+                return True
+        return False
+
+    external_symlinks = list(filter(lambda link: not
+                             os.path.realpath(link).startswith(
+                                 unpack_dir) and
+                             not _in_patterns(libc6_pats,
+                                              os.path.basename(link)),
+                             pkg_files))
+
+    return external_symlinks
+
+
+# check_results(report, expected_counts, expected)
+# Verify exact counts of types
+#   expected_counts={'info': 1, 'warn': 0, 'error': 0}
+#   self.check_results(report, expected_counts)
+# Verify counts of warn and error types
+#   expected_counts={'info': None, 'warn': 0, 'error': 0}
+#   self.check_results(report, expected_counts)
+# Verify exact messages:
+#   expected = dict()
+#   expected['info'] = dict()
+#   expected['warn'] = dict()
+#   expected['warn']['skeleton_baz'] = "TODO"
+#   expected['error'] = dict()
+#   self.check_results(r, expected=expected)
+
+
+def check_results(testobj, report,
+                  expected_counts={'info': 1, 'warn': 0, 'error': 0},
+                  expected=None):
+    if expected is not None:
+        for t in expected.keys():
+            for r in expected[t]:
+                testobj.assertTrue(r in report[t],
+                                   "Could not find '%s' (%s) in:\n%s" %
+                                   (r, t, json.dumps(report, indent=2)))
+                for k in expected[t][r]:
+                    testobj.assertTrue(k in report[t][r],
+                                       "Could not find '%s' (%s) in:\n%s" %
+                                       (k, r, json.dumps(report, indent=2)))
+                testobj.assertEqual(expected[t][r][k], report[t][r][k])
+    else:
+        for k in expected_counts.keys():
+            if expected_counts[k] is None:
+                continue
+            testobj.assertEqual(len(report[k]), expected_counts[k],
+                                "(%s not equal)\n%s" %
+                                (k, json.dumps(report, indent=2)))

=== modified file 'clickreviews/cr_lint.py'
--- clickreviews/cr_lint.py	2016-02-10 19:29:39 +0000
+++ clickreviews/cr_lint.py	2016-02-11 18:32:45 +0000
@@ -27,13 +27,14 @@
 from clickreviews.cr_common import (
     ClickReview,
 )
-
 from clickreviews.common import (
     open_file_read,
     cmd,
     error,
 )
-
+from clickreviews.common import (
+    find_external_symlinks,
+)
 
 CONTROL_FILE_NAMES = ["control", "manifest", "preinst"]
 MINIMUM_CLICK_FRAMEWORK_VERSION = "0.4"
@@ -538,61 +539,19 @@
         '''Check if symlinks in the click package go out to the system.'''
         if not self.is_click and not self.is_snap1:
             return
-        if self.is_snap1 and self.pkg_yaml['type'] not in ['app', 'framework']:
+
+        if self.is_snap1 and 'type' in self.snap_yaml and \
+                self.snap_yaml['type'] not in ['app', 'framework']:
             return
 
         t = 'info'
         n = self._get_check_name('external_symlinks')
         s = 'OK'
 
-        common = '(-[0-9.]+)?\.so(\.[0-9.]+)?'
-        libc6_libs = ['ld-*.so',
-                      'libanl',
-                      'libBrokenLocale',
-                      'libc',
-                      'libcidn',
-                      'libcrypt',
-                      'libdl',
-                      'libmemusage',
-                      'libm',
-                      'libnsl',
-                      'libnss_compat',
-                      'libnss_dns',
-                      'libnss_files',
-                      'libnss_hesiod',
-                      'libnss_nisplus',
-                      'libnss_nis',
-                      'libpcprofile',
-                      'libpthread',
-                      'libresolv',
-                      'librt',
-                      'libSegFault',
-                      'libthread_db',
-                      'libutil',
-                      ]
-        libc6_pats = []
-        for lib in libc6_libs:
-            libc6_pats.append(re.compile(r'%s%s' % (lib, common)))
-        libc6_pats.append(re.compile(r'ld-*.so$'))
-        libc6_pats.append(re.compile(r'ld-linux-*.so\.[0-9.]+$'))
-
-        def _in_patterns(pats, f):
-            for pat in pats:
-                if pat.search(f):
-                    return True
-            return False
-
-        external_symlinks = list(filter(lambda link: not
-                                 os.path.realpath(link).startswith(
-                                     self.unpack_dir) and
-                                 not _in_patterns(libc6_pats,
-                                                  os.path.basename(link)),
-                                 self.pkg_files))
-
-        if external_symlinks:
+        links = find_external_symlinks(self.unpack_dir, self.pkg_files)
+        if len(links) > 0:
             t = 'error'
-            s = 'package contains external symlinks: %s' % \
-                ', '.join(external_symlinks)
+            s = 'package contains external symlinks: %s' % ', '.join(links)
         self._add_result(t, n, s)
 
     def check_pkgname(self):

=== modified file 'clickreviews/cr_scope.py' (properties changed: +x to -x)
=== modified file 'clickreviews/cr_tests.py'
--- clickreviews/cr_tests.py	2016-02-09 22:26:36 +0000
+++ clickreviews/cr_tests.py	2016-02-11 18:32:45 +0000
@@ -713,43 +713,10 @@
                                              self.test_control['Version'],
                                              self.test_control['Architecture'])
 
-    #
-    # check_results(report, expected_counts, expected)
-    # Verify exact counts of types
-    #   expected_counts={'info': 1, 'warn': 0, 'error': 0}
-    #   self.check_results(report, expected_counts)
-    # Verify counts of warn and error types
-    #   expected_counts={'info': None, 'warn': 0, 'error': 0}
-    #   self.check_results(report, expected_counts)
-    # Verify exact messages:
-    #   expected = dict()
-    #   expected['info'] = dict()
-    #   expected['warn'] = dict()
-    #   expected['warn']['skeleton_baz'] = "TODO"
-    #   expected['error'] = dict()
-    #   self.check_results(r, expected=expected)
-    #
     def check_results(self, report,
                       expected_counts={'info': 1, 'warn': 0, 'error': 0},
                       expected=None):
-        if expected is not None:
-            for t in expected.keys():
-                for r in expected[t]:
-                    self.assertTrue(r in report[t],
-                                    "Could not find '%s' (%s) in:\n%s" %
-                                    (r, t, json.dumps(report, indent=2)))
-                    for k in expected[t][r]:
-                        self.assertTrue(k in report[t][r],
-                                        "Could not find '%s' (%s) in:\n%s" %
-                                        (k, r, json.dumps(report, indent=2)))
-                    self.assertEqual(expected[t][r][k], report[t][r][k])
-        else:
-            for k in expected_counts.keys():
-                if expected_counts[k] is None:
-                    continue
-                self.assertEqual(len(report[k]), expected_counts[k],
-                                 "(%s not equal)\n%s" %
-                                 (k, json.dumps(report, indent=2)))
+        common.check_results(self, report, expected_counts, expected)
 
     def check_manual_review(self, report, check_name,
                             result_type='error', manual_review=True):

=== added directory 'clickreviews/data'
=== added file 'clickreviews/data/icon.png'
Binary files clickreviews/data/icon.png	1970-01-01 00:00:00 +0000 and clickreviews/data/icon.png	2016-02-11 18:32:45 +0000 differ
=== modified file 'clickreviews/sr_common.py'
--- clickreviews/sr_common.py	2016-02-10 19:32:10 +0000
+++ clickreviews/sr_common.py	2016-02-11 18:32:45 +0000
@@ -92,7 +92,7 @@
         if snap_yaml:
             try:
                 self.snap_yaml = yaml.safe_load(snap_yaml)
-            except Exception:
+            except Exception:  # pragma: nocover
                 error("Could not load snap.yaml. Is it properly formatted?")
 
         # default to 'app'
@@ -108,13 +108,21 @@
         if 'type' in self.snap_yaml and self.snap_yaml['type'] == 'gadget':
             self.is_snap_gadget = True
 
-    def _extract_snap_yaml(self):
+    # Since coverage is looked at via the testsuite and the testsuite mocks
+    # this out, don't cover this
+    def _extract_snap_yaml(self):  # pragma: nocover
         '''Extract and read the snappy 16.04 snap.yaml'''
         y = os.path.join(self.unpack_dir, "meta/snap.yaml")
         if not os.path.isfile(y):
             return None  # snappy packaging is still optional
         return open_file_read(y)
 
+    # Since coverage is looked at via the testsuite and the testsuite mocks
+    # this out, don't cover this
+    def _get_unpack_dir(self):  # pragma: nocover
+        '''Get unpack directory'''
+        return self.unpack_dir
+
     def _verify_pkgname(self, n):
         '''Verify package name'''
         pat = re.compile(r'^[a-z0-9][a-z0-9+-]+$')

=== added file 'clickreviews/sr_lint.py'
--- clickreviews/sr_lint.py	1970-01-01 00:00:00 +0000
+++ clickreviews/sr_lint.py	2016-02-11 18:32:45 +0000
@@ -0,0 +1,1203 @@
+'''sr_lint.py: lint checks'''
+#
+# Copyright (C) 2013-2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import print_function
+from clickreviews.frameworks import Frameworks
+from clickreviews.sr_common import (
+    SnapReview,
+)
+from clickreviews.common import (
+    find_external_symlinks,
+)
+import glob
+import os
+import re
+
+
+class SnapReviewLint(SnapReview):
+    '''This class represents snap lint reviews'''
+
+    def __init__(self, fn, overrides=None):
+        '''Set up the class.'''
+        SnapReview.__init__(self, fn, "lint-snap-v2", overrides=overrides)
+        if not self.is_snap2:
+            return
+
+        self.valid_compiled_architectures = ['armhf',
+                                             'i386',
+                                             'amd64',
+                                             'arm64',
+                                             ]
+        self.valid_architectures = ['all'] + self.valid_compiled_architectures
+        self.vcs_files = ['.bzr*',
+                          # '.excludes',  # autogenerated by SDK
+                          '.git*',
+                          '.idea',
+                          '.svn*',
+                          '.hg',
+                          '.project',
+                          'CVS*',
+                          'RCS*'
+                          ]
+
+        self._list_all_compiled_binaries()
+
+        # Valid values for 'type' in packaging yaml
+        # - app
+        # - framework
+        # - kernel
+        # - gadget
+        # - os
+        self.valid_snap_types = ['app',
+                                 'framework',
+                                 'kernel',
+                                 'gadget',
+                                 'os',
+                                 ]
+        self.redflagged_snap_types = ['framework',
+                                      'kernel',
+                                      'gadget',
+                                      'os',
+                                      ]
+
+    def check_architectures(self):
+        '''Check architectures in snap.yaml is valid'''
+        if not self.is_snap2:
+            return
+
+        t = 'info'
+        n = self._get_check_name('architecture_valid')
+        s = 'OK'
+
+        key = 'architectures'
+        if key not in self.snap_yaml:
+            s = 'OK (%s not specified)' % key
+            self._add_result(t, n, s)
+            return
+
+        if not isinstance(self.snap_yaml[key], list):
+            t = 'error'
+            s = "invalid %s entry: %s (not a list)" % (key,
+                                                       self.snap_yaml[key])
+        else:
+            bad_archs = []
+            for arch in self.snap_yaml[key]:
+                if arch not in self.valid_architectures:
+                    bad_archs.append(arch)
+                if len(bad_archs) > 0:
+                    t = 'error'
+                    s = "invalid multi architecture: %s" % ",".join(bad_archs)
+        self._add_result(t, n, s)
+
+    def check_description(self):
+        '''Check description'''
+        if not self.is_snap2:
+            return
+
+        key = 'description'
+
+        t = 'info'
+        n = self._get_check_name('%s_present' % key)
+        s = 'OK'
+        if key not in self.snap_yaml:
+            s = 'OK (optional %s field not specified)' % key
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name(key)
+        s = 'OK'
+        if not isinstance(self.snap_yaml[key], str):
+            t = 'error'
+            s = "invalid %s entry: %s (not a str)" % (key, self.snap_yaml[key])
+            self._add_result(t, n, s)
+            return
+        elif len(self.snap_yaml[key]) < 1:
+            t = 'error'
+            s = "invalid %s entry (empty)" % (key)
+        elif len(self.snap_yaml[key]) < len(self.snap_yaml['name']):
+            t = 'info'
+            s = "%s is too short: '%s'" % (key, self.snap_yaml[key])
+        self._add_result(t, n, s)
+
+    def check_frameworks(self):
+        '''Check framework'''
+        if not self.is_snap2:
+            return
+
+        key = 'frameworks'
+
+        t = 'info'
+        n = self._get_check_name(key)
+        l = "http://askubuntu.com/questions/460512/what-framework-should-i-use-in-my-manifest-file"
+
+        if key not in self.snap_yaml:
+            s = 'OK (%s not specified)' % key
+            self._add_result(t, n, s)
+            return
+
+        if not isinstance(self.snap_yaml[key], list):
+            t = 'error'
+            s = "invalid %s entry: %s (not a list)" % (key,
+                                                       self.snap_yaml[key])
+            self._add_result(t, n, s)
+            return
+        elif len(self.snap_yaml[key]) < 1:
+            t = 'error'
+            s = "invalid %s entry (empty)" % (key)
+            self._add_result(t, n, s)
+            return
+
+        framework_overrides = self.overrides.get('framework', {})
+        frameworks = Frameworks(overrides=framework_overrides)
+
+        for framework in self.snap_yaml[key]:
+            if framework in frameworks.AVAILABLE_FRAMEWORKS:
+                t = 'info'
+                s = 'OK'
+                self._add_result(t, n, s)
+                # If it's an available framework, we're done checking
+                return
+            elif framework in frameworks.DEPRECATED_FRAMEWORKS:
+                t = 'warn'
+                s = "'%s' is deprecated. Please use a newer framework" % \
+                    framework
+                self._add_result(t, n, s, l)
+                return
+            elif framework in frameworks.OBSOLETE_FRAMEWORKS:
+                t = 'error'
+                s = "'%s' is obsolete. Please use a newer framework" % \
+                    framework
+                self._add_result(t, n, s, l)
+                return
+            else:
+                # None of the above checks triggered, this is an unknown
+                # framework
+                t = 'error'
+                s = "'%s' is not a supported framework" % \
+                    framework
+                self._add_result(t, n, s, l)
+
+    # TODO: verify this is a field
+    def check_license_agreement(self):
+        '''Check license-agreement'''
+        if not self.is_snap2:
+            return
+
+        key = 'license-agreement'
+
+        t = 'info'
+        n = self._get_check_name('%s_present' % key)
+        s = 'OK'
+        if key not in self.snap_yaml:
+            s = 'OK (optional %s field not specified)' % key
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name(key)
+        s = 'OK'
+        if not isinstance(self.snap_yaml[key], str):
+            t = 'error'
+            s = "invalid %s entry: %s (not a str)" % (key, self.snap_yaml[key])
+            self._add_result(t, n, s)
+            return
+        elif len(self.snap_yaml[key]) < 1:
+            t = 'error'
+            s = "invalid %s entry (empty)" % (key)
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+    def check_license_version(self):
+        '''license-version'''
+        if not self.is_snap2:
+            return
+
+        key = 'license-version'
+        t = 'info'
+        n = self._get_check_name('%s_present' % key)
+        s = 'OK'
+        if key not in self.snap_yaml:
+            s = 'OK (optional %s field not specified)' % key
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name(key)
+        s = 'OK'
+        if not isinstance(self.snap_yaml[key], str):
+            t = 'error'
+            s = "invalid %s entry: %s (not a str)" % (key, self.snap_yaml[key])
+            self._add_result(t, n, s)
+            return
+        elif len(self.snap_yaml[key]) < 1:
+            t = 'error'
+            s = "invalid %s entry (empty)" % (key)
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+    def check_name(self):
+        '''Check package name'''
+        if not self.is_snap2:
+            return
+
+        t = 'info'
+        n = self._get_check_name('name_valid')
+        s = 'OK'
+        if 'name' not in self.snap_yaml:
+            t = 'error'
+            s = "could not find 'name' in yaml"
+        elif not isinstance(self.snap_yaml['name'], str):
+            t = 'error'
+            s = "malformed 'name': %s (not a str)" % (self.snap_yaml['name'])
+        elif not self._verify_pkgname(self.snap_yaml['name']):
+            t = 'error'
+            s = "malformed 'name': '%s'" % self.snap_yaml['name']
+        self._add_result(t, n, s)
+
+    def check_summary(self):
+        '''Check summary'''
+        if not self.is_snap2:
+            return
+
+        key = 'summary'
+
+        t = 'info'
+        n = self._get_check_name('%s_present' % key)
+        s = 'OK'
+        if key not in self.snap_yaml:
+            s = 'OK (optional %s field not specified)' % key
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name(key)
+        s = 'OK'
+        if not isinstance(self.snap_yaml[key], str):
+            t = 'error'
+            s = "invalid %s entry: %s (not a str)" % (key, self.snap_yaml[key])
+            self._add_result(t, n, s)
+            return
+        elif len(self.snap_yaml[key]) < 1:
+            t = 'error'
+            s = "invalid %s entry (empty)" % (key)
+        elif len(self.snap_yaml[key]) < len(self.snap_yaml['name']):
+            t = 'info'
+            s = "%s is too short: '%s'" % (key, self.snap_yaml[key])
+        self._add_result(t, n, s)
+
+    def check_type(self):
+        '''Check type'''
+        if not self.is_snap2 or 'type' not in self.snap_yaml:
+            return
+
+        t = 'info'
+        n = self._get_check_name('snap_type_valid')
+        s = 'OK'
+        if self.snap_yaml['type'] not in self.valid_snap_types:
+            t = 'error'
+            s = "unknown 'type': '%s'" % self.snap_yaml['type']
+        self._add_result(t, n, s)
+
+    def check_type_redflagged(self):
+        '''Check if type is redflagged'''
+        if not self.is_snap2 or 'type' not in self.snap_yaml:
+            return
+
+        t = 'info'
+        n = self._get_check_name('snap_type_redflag')
+        s = "OK"
+        l = None
+        manual_review = False
+        if self.snap_yaml['type'] in self.redflagged_snap_types:
+            t = 'error'
+            s = "(NEEDS REVIEW) type '%s' not allowed" % self.snap_yaml['type']
+            manual_review = True
+            if self.snap_yaml['type'] == "framework":
+                l = "https://developer.ubuntu.com/en/snappy/guides/frameworks/"
+        self._add_result(t, n, s, link=l, manual_review=manual_review)
+
+    def check_version(self):
+        '''Check package version'''
+        if not self.is_snap2:
+            return
+
+        t = 'info'
+        n = self._get_check_name('version_valid')
+        s = 'OK'
+        if 'version' not in self.snap_yaml:
+            t = 'error'
+            s = "could not find 'version' in yaml"
+        elif not self._verify_pkgversion(self.snap_yaml['version']):
+            t = 'error'
+            s = "malformed 'version': '%s'" % self.snap_yaml['version']
+        self._add_result(t, n, s)
+
+    def check_config(self):
+        '''Check config'''
+        if not self.is_snap2:
+            return
+
+        fn = os.path.join(self._get_unpack_dir(), 'meta/hooks/config')
+        if fn not in self.pkg_files:
+            return
+
+        t = 'info'
+        n = self._get_check_name('config_hook_executable')
+        s = 'OK'
+        if not self._check_innerpath_executable(fn):
+            t = 'error'
+            s = 'meta/hooks/config is not executable'
+        self._add_result(t, n, s)
+
+    def check_icon(self):
+        '''Check icon'''
+        # see docs/meta.md and docs/gadget.md
+        if not self.is_snap2 or 'icon' not in self.snap_yaml:
+            return
+
+        t = 'info'
+        n = self._get_check_name('icon_present')
+        s = 'OK'
+        if 'type' in self.snap_yaml and self.snap_yaml['type'] != "gadget":
+            t = 'warn'
+            s = 'icon only used with gadget snaps'
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name('icon_empty')
+        s = 'OK'
+        if len(self.snap_yaml['icon']) == 0:
+            t = 'error'
+            s = "icon entry is empty"
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name('icon_absolute_path')
+        s = 'OK'
+        if self.snap_yaml['icon'].startswith('/'):
+            t = 'error'
+            s = "icon entry '%s' should not specify absolute path" % \
+                self.snap_yaml['icon']
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name('icon_exists')
+        s = 'OK'
+        fn = self._path_join(self._get_unpack_dir(), self.snap_yaml['icon'])
+        if fn not in self.pkg_files:
+            t = 'error'
+            s = "icon entry '%s' does not exist" % self.snap_yaml['icon']
+        self._add_result(t, n, s)
+
+    def check_unknown_entries(self):
+        '''Check for any unknown fields'''
+        if not self.is_snap2:
+            return
+
+        t = 'info'
+        n = self._get_check_name('unknown_field')
+        s = 'OK'
+        unknown = []
+        for f in self.snap_yaml:
+            if f not in self.snappy_required + self.snappy_optional:
+                unknown.append(f)
+        if len(unknown) > 0:
+            t = 'warn'
+            s = "unknown entries in snap.yaml: '%s'" % \
+                (",".join(sorted(unknown)))
+        self._add_result(t, n, s)
+
+    def check_is_squashfs(self):
+        '''Check snapfs'''
+        if not self.is_snap2:
+            return
+
+        # Manual review until have squashfs tests
+        t = 'error'
+        n = self._get_check_name('is_squashfs')
+        s = "(NEEDS REVIEW) squashfs pkg"
+        manual_review = True
+        self._add_result(t, n, s, manual_review=manual_review)
+
+    def check_apps(self):
+        '''Check apps'''
+        if not self.is_snap2:
+            return
+
+        key = 'apps'
+
+        t = 'info'
+        n = self._get_check_name('%s_present' % key)
+        s = 'OK'
+        if key not in self.snap_yaml:
+            s = 'OK (optional %s field not specified)' % key
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name(key)
+        s = 'OK'
+        if not isinstance(self.snap_yaml[key], dict):
+            t = 'error'
+            s = "invalid %s entry: %s (not a dict)" % (key,
+                                                       self.snap_yaml[key])
+            self._add_result(t, n, s)
+            return
+        elif len(self.snap_yaml[key].keys()) < 1:
+            t = 'error'
+            s = "invalid %s entry (empty)" % (key)
+            self._add_result(t, n, s)
+            return
+        self._add_result(t, n, s)
+
+        for app in self.snap_yaml[key]:
+            t = 'info'
+            n = self._get_check_name('%s_entry' % key, app=app)
+            s = 'OK'
+
+            if not isinstance(self.snap_yaml[key][app], dict):
+                t = 'error'
+                s = "invalid entry: %s (not a dict)" % (
+                    self.snap_yaml[key][app])
+                self._add_result(t, n, s)
+                continue
+            elif len(self.snap_yaml[key][app].keys()) < 1:
+                t = 'error'
+                s = "invalid entry for '%s' (empty)" % (app)
+                self._add_result(t, n, s)
+                continue
+            self._add_result(t, n, s)
+
+            for field in self.apps_required:
+                t = 'info'
+                n = self._get_check_name('%s_required' % key, app=app)
+                s = 'OK'
+                if field not in self.snap_yaml[key][app]:
+                    t = 'error'
+                    s = "required field '%s' not specified" % field
+                self._add_result(t, n, s)
+
+            t = 'info'
+            n = self._get_check_name('%s_unknown' % key, app=app)
+            s = 'OK'
+            unknown = []
+            for field in self.snap_yaml[key][app]:
+                if field not in self.apps_required + self.apps_optional:
+                    unknown.append(field)
+            if len(unknown) > 0:
+                t = 'warn'
+                s = "unknown fields: '%s'" % (",".join(sorted(unknown)))
+            self._add_result(t, n, s)
+
+    def _verify_value_is_file(self, app, key):
+            t = 'info'
+            n = self._get_check_name('%s' % key, app=app)
+            s = 'OK'
+            if not isinstance(self.snap_yaml['apps'][app][key], str):
+                t = 'error'
+                s = "%s '%s' (not a str)" % (key,
+                                             self.snap_yaml['apps'][app][key])
+                self._add_result(t, n, s)
+            elif len(self.snap_yaml['apps'][app][key]) < 1:
+                t = 'error'
+                s = "invalid %s (empty)" % (key)
+                self._add_result(t, n, s)
+            else:
+                fn = self._path_join(self._get_unpack_dir(),
+                                     self.snap_yaml['apps'][app][key])
+                if fn not in self.pkg_files:
+                    t = 'error'
+                    s = "%s does not exist" % (
+                        self.snap_yaml['apps'][app][key])
+            self._add_result(t, n, s)
+
+    def check_apps_command(self):
+        '''Check apps - command'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'command'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_value_is_file(app, key)
+
+    def check_apps_stop(self):
+        '''Check apps - stop'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'stop'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_value_is_file(app, key)
+
+    def check_apps_poststop(self):
+        '''Check apps - poststop'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'poststop'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_value_is_file(app, key)
+
+    def check_apps_stop_timeout(self):
+        '''Check apps - stop-timeout'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'stop-timeout'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            t = 'info'
+            n = self._get_check_name('%s' % key, app=app)
+            s = "OK"
+            if not isinstance(self.snap_yaml['apps'][app][key], int) and \
+                    not isinstance(self.snap_yaml['apps'][app][key], str):
+                t = 'error'
+                s = "'%s' is not a string or integer" % key
+            elif not re.search(r'[0-9]+[ms]?$',
+                               str(self.snap_yaml['apps'][app][key])):
+                t = 'error'
+                s = "'%s' is not of form NN[ms] (%s)" % \
+                    (self.snap_yaml['apps'][app][key], key)
+            self._add_result(t, n, s)
+
+            if t == 'error':
+                continue
+
+            t = 'info'
+            n = self._get_check_name('%s_range' % key, app=app)
+            s = "OK"
+            st = int(str(self.snap_yaml['apps'][app][key]).rstrip(r'[ms]'))
+            if st < 0 or st > 60:
+                t = 'error'
+                s = "stop-timeout '%d' out of range (0-60)" % \
+                    self.snap_yaml['apps'][app][key]
+            self._add_result(t, n, s)
+
+    def _verify_valid_values(self, app, key, valid):
+        '''Verify valid values for key in app'''
+        t = 'info'
+        n = self._get_check_name('%s' % key, app=app)
+        s = 'OK'
+        if not isinstance(self.snap_yaml['apps'][app][key], str):
+            t = 'error'
+            s = "%s '%s' (not a str)" % (key,
+                                         self.snap_yaml['apps'][app][key])
+            self._add_result(t, n, s)
+        elif len(self.snap_yaml['apps'][app][key]) < 1:
+            t = 'error'
+            s = "invalid %s (empty)" % (key)
+            self._add_result(t, n, s)
+        elif self.snap_yaml['apps'][app][key] not in valid:
+            t = 'error'
+            s = "invalid %s: '%s'" % (key, self.snap_yaml['apps'][app][key])
+        self._add_result(t, n, s)
+
+    def check_apps_daemon(self):
+        '''Check apps - daemon'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        valid = ["simple",
+                 "forking",
+                 "oneshot",
+                 "dbus",
+                 ]
+
+        for app in self.snap_yaml['apps']:
+            key = 'daemon'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_valid_values(app, key, valid)
+
+    def check_apps_nondaemon(self):
+        '''Check apps - non-daemon'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        # Certain options require 'daemon' so list the keys that are shared
+        # by services and binaries
+        ok_keys = ['command', 'uses']
+
+        for app in self.snap_yaml['apps']:
+            needs_daemon = []
+            for key in self.snap_yaml['apps'][app]:
+                if key not in self.apps_optional or \
+                        key == 'daemon' or \
+                        key in ok_keys or \
+                        'daemon' in self.snap_yaml['apps'][app]:
+                    continue
+                needs_daemon.append(key)
+
+            t = 'info'
+            n = self._get_check_name('daemon_required', app=app)
+            s = "OK"
+            if len(needs_daemon) > 0:
+                t = 'error'
+                s = "'%s' must be used with 'daemon'" % ",".join(needs_daemon)
+            self._add_result(t, n, s)
+
+    def check_apps_restart_condition(self):
+        '''Check apps - restart-condition'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        valid = ["always",
+                 "never",
+                 "on-abnormal",
+                 "on-abort",
+                 "on-failure",
+                 "on-success",
+                 ]
+
+        for app in self.snap_yaml['apps']:
+            key = 'restart-condition'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_valid_values(app, key, valid)
+
+    def check_apps_busname(self):
+        '''Check apps - bus-name'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'bus-name'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            t = 'info'
+            n = self._get_check_name('%s_framework' % key, app=app)
+            s = 'OK'
+            if 'type' in self.snap_yaml and \
+                    self.snap_yaml['type'] != 'framework':
+                t = 'error'
+                s = "Use of bus-name requires package be of 'type: framework'"
+            self._add_result(t, n, s)
+
+            t = 'info'
+            n = self._get_check_name('%s' % key, app=app)
+            s = 'OK'
+            l = None
+            if not isinstance(self.snap_yaml['apps'][app][key], str):
+                t = 'error'
+                s = "%s '%s' (not a str)" % (key,
+                                             self.snap_yaml['apps'][app][key])
+            elif len(self.snap_yaml['apps'][app][key]) < 1:
+                t = 'error'
+                s = "invalid %s (empty)" % (key)
+            elif not re.search(
+                    r'^[A-Za-z0-9][A-Za-z0-9_-]*(\.[A-Za-z0-9][A-Za-z0-9_-]*)+$',
+                    self.snap_yaml['apps'][app][key]):
+                t = 'error'
+                l = 'http://dbus.freedesktop.org/doc/dbus-specification.html'
+                s = "'%s' is not of form '^[A-Za-z0-9][A-Za-z0-9_-]*(\\.[A-Za-z0-9][A-Za-z0-9_-]*)+$'" % \
+                    (self.snap_yaml['apps'][app][key])
+            self._add_result(t, n, s, l)
+            if t == 'error':
+                continue
+
+            t = 'info'
+            n = self._get_check_name('%s_matches_name' % key, app=app)
+            s = 'OK'
+            suggested = [self.snap_yaml['name'],
+                         "%s.%s" % (self.snap_yaml['name'], app)
+                         ]
+            found = False
+            for name in suggested:
+                if self.snap_yaml['apps'][app][key].endswith(name):
+                    found = True
+                    break
+            if not found:
+                t = 'error'
+                s = "'%s' doesn't end with one of: %s" % \
+                    (self.snap_yaml['apps'][app][key], ", ".join(suggested))
+            self._add_result(t, n, s)
+
+    def check_apps_ports(self):
+        '''Check apps - ports'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        valid_keys = ['internal', 'external']
+        valid_subkeys = ['port', 'negotiable']
+        for app in self.snap_yaml['apps']:
+            if 'ports' not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            t = 'info'
+            n = self._get_check_name('ports', app=app)
+            s = 'OK'
+            l = None
+            if not isinstance(self.snap_yaml['apps'][app]['ports'], dict):
+                t = 'error'
+                s = "ports '%s' (not a dict)" % (
+                    self.snap_yaml['apps'][app]['ports'])
+            elif len(self.snap_yaml['apps'][app]['ports'].keys()) < 1:
+                t = 'error'
+                s = "'ports' must contain 'internal' and/or 'external'"
+            self._add_result(t, n, s, l)
+            if t == 'error':
+                continue
+
+            # unknown
+            unknown = []
+            for key in self.snap_yaml['apps'][app]['ports']:
+                if key not in valid_keys:
+                    unknown.append(key)
+            if len(unknown) > 0:
+                t = 'error'
+                n = self._get_check_name('ports_unknown_key', extra=key,
+                                         app=app)
+                s = "Unknown '%s' for ports" % (",".join(unknown))
+                self._add_result(t, n, s)
+
+            port_pat = re.compile(r'^[0-9]+/[a-z0-9\-]+$')
+            for key in valid_keys:
+                if key not in self.snap_yaml['apps'][app]['ports']:
+                    continue
+
+                if len(self.snap_yaml['apps'][app]['ports'][key].keys()) < 1:
+                    t = 'error'
+                    n = self._get_check_name('ports', extra=key, app=app)
+                    s = 'Could not find any %s ports' % key
+                    self._add_result(t, n, s)
+                    continue
+
+                for tagname in self.snap_yaml['apps'][app]['ports'][key]:
+                    entry = self.snap_yaml['apps'][app]['ports'][key][tagname]
+                    if len(entry.keys()) < 1 or ('negotiable' not in entry and
+                                                 'port' not in entry):
+                        t = 'error'
+                        n = self._get_check_name('ports', extra=key, app=app)
+                        s = "Could not find 'port' or 'negotiable' in '%s'" % \
+                            tagname
+                        self._add_result(t, n, s)
+                        continue
+
+                    # unknown
+                    unknown = []
+                    for subkey in entry:
+                        if subkey not in valid_subkeys:
+                            unknown.append(subkey)
+                    if len(unknown) > 0:
+                        t = 'error'
+                        n = self._get_check_name('ports_unknown_subkey',
+                                                 extra=key, app=app)
+                        s = "Unknown '%s' for %s" % (",".join(unknown),
+                                                     tagname)
+                        self._add_result(t, n, s)
+
+                    # port
+                    subkey = 'port'
+                    t = 'info'
+                    n = self._get_check_name('ports_%s_format' % tagname,
+                                             extra=subkey)
+                    s = 'OK'
+                    if subkey not in entry:
+                        s = 'OK (skipped, not found)'
+                    elif not isinstance(entry[subkey], str):
+                        t = 'error'
+                        s = "invalid entry: %s (not a str)" % (entry[subkey])
+                    else:
+                        tmp = entry[subkey].split('/')
+                        if not port_pat.search(entry[subkey]) or \
+                           int(tmp[0]) < 1 or int(tmp[0]) > 65535:
+                            t = 'error'
+                            s = "'%s' should be of form " % entry[subkey] + \
+                                "'port/protocol' where port is an integer " + \
+                                "(1-65535) and protocol is found in " + \
+                                "/etc/protocols"
+                    self._add_result(t, n, s)
+
+                    # negotiable
+                    subkey = 'negotiable'
+                    t = 'info'
+                    n = self._get_check_name('ports_%s_format' % tagname,
+                                             extra=subkey)
+                    s = 'OK'
+                    if subkey not in entry:
+                        s = 'OK (skipped, not found)'
+                    elif not isinstance(entry[subkey], bool):
+                        t = 'error'
+                        s = "'%s: %s' should be either 'yes' or 'no'" % \
+                            (subkey, entry[subkey])
+                    self._add_result(t, n, s)
+
+    def check_apps_socket(self):
+        '''Check apps - socket'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'socket'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            t = 'info'
+            n = self._get_check_name(key, app=app)
+            s = 'OK'
+            if not isinstance(self.snap_yaml['apps'][app][key], bool):
+                t = 'error'
+                s = "'%s: %s' should be either 'yes' or 'no'" % (
+                    key, self.snap_yaml['apps'][app][key])
+            elif 'listen-stream' not in self.snap_yaml['apps'][app]:
+                t = 'error'
+                s = "'socket' specified without 'listen-stream'"
+            self._add_result(t, n, s)
+
+    def check_apps_listen_stream(self):
+        '''Check apps - listen-stream'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'listen-stream'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            t = 'info'
+            n = self._get_check_name(key, app=app)
+            s = 'OK'
+            if not isinstance(self.snap_yaml['apps'][app][key], str):
+                t = 'error'
+                s = "invalid entry: %s (not a str)" % (
+                    self.snap_yaml['apps'][app][key])
+            elif len(self.snap_yaml['apps'][app][key]) == 0:
+                t = 'error'
+                s = "'%s' is empty" % key
+            self._add_result(t, n, s)
+            if t == 'error':
+                continue
+
+            t = 'info'
+            n = self._get_check_name('%s_matches_name' % key, app=app)
+            s = 'OK'
+            sock = self.snap_yaml['apps'][app][key]
+            pkgname = self.snap_yaml['name']
+            if sock.startswith('@'):
+                if sock != '@%s' % pkgname and \
+                        not sock.startswith('@%s_' % pkgname):
+                    t = 'error'
+                    s = ("abstract socket '%s' is neither '%s' nor starts "
+                         "with '%s'" % (sock, '@%s' % pkgname,
+                                        '@%s_' % pkgname))
+            elif sock.startswith('/'):
+                found = False
+                for path in ["/tmp/",
+                             "/var/lib/snaps/%s/" % pkgname,
+                             "/var/lib/snaps/%s." % pkgname,
+                             "/run/shm/snaps/%s/" % pkgname,
+                             "/run/shm/snaps/%s." % pkgname]:
+                    if sock.startswith(path):
+                        found = True
+                        break
+                if not found:
+                    t = 'error'
+                    s = ("named socket '%s' should be in a writable "
+                         "app-specific area or /tmp" % sock)
+            else:
+                t = 'error'
+                s = ("'%s' does not specify an abstract socket (starts "
+                     "with '@') or absolute filename" % (sock))
+            self._add_result(t, n, s)
+
+    def _verify_valid_socket(self, app, key):
+        '''Verify valid values for socket key'''
+        t = 'info'
+        n = self._get_check_name(key, app=app)
+        s = 'OK'
+        if not isinstance(self.snap_yaml['apps'][app][key], str):
+            t = 'error'
+            s = "invalid entry: %s (not a str)" % (
+                self.snap_yaml['apps'][app][key])
+        elif len(self.snap_yaml['apps'][app][key]) == 0:
+            t = 'error'
+            s = "'%s' is empty" % key
+        elif 'listen-stream' not in self.snap_yaml['apps'][app]:
+            t = 'error'
+            s = "'%s' specified without 'listen-stream'" % key
+        self._add_result(t, n, s)
+        if t == 'error':
+            return
+
+        t = 'error'
+        n = self._get_check_name('%s_reserved' % key, app=app)
+        s = "'%s' should not be used until snappy supports per-app users" \
+            % key
+        self._add_result(t, n, s)
+
+        t = 'info'
+        n = self._get_check_name("%s_matches_name" % key, app=app)
+        s = 'OK'
+        if self.snap_yaml['apps'][app][key] != self.snap_yaml['name']:
+            t = 'error'
+            s = "'%s' != '%s'" % (self.snap_yaml['apps'][app][key],
+                                  self.snap_yaml['name'])
+        self._add_result(t, n, s)
+
+    def check_apps_socket_user(self):
+        '''Check apps - socket-user'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'socket-user'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_valid_socket(app, key)
+
+    def check_apps_socket_group(self):
+        '''Check apps - socket-group'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'socket-group'
+            if key not in self.snap_yaml['apps'][app]:
+                # We check for required elsewhere
+                continue
+
+            self._verify_valid_socket(app, key)
+
+    def check_uses(self):
+        '''Check uses'''
+        if not self.is_snap2 or 'uses' not in self.snap_yaml:
+            return
+
+        for slot in self.snap_yaml['uses']:
+            # If the 'type' name is the same as the 'slot' name, then 'type'
+            # is optional since the type name and the slot name are the same
+            skill_type = slot
+            if 'type' in self.snap_yaml['uses'][slot]:
+                skill_type = self.snap_yaml['uses'][slot]['type']
+
+                key = 'type'
+                t = 'info'
+                n = self._get_check_name(key, extra=slot)
+                s = 'OK'
+                if not isinstance(self.snap_yaml['uses'][slot][key], str):
+                    t = 'error'
+                    s = "invalid %s: %s (not a str)" % \
+                        (key, self.snap_yaml['uses'][slot][key])
+                elif len(self.snap_yaml['uses'][slot][key]) == 0:
+                    t = 'error'
+                    s = "'%s' is empty" % key
+                self._add_result(t, n, s)
+                if t == 'error':
+                    continue
+
+            t = 'info'
+            n = self._get_check_name(skill_type, extra=slot)
+            s = 'OK'
+            if skill_type not in self.skill_types:
+                t = 'error'
+                s = "unknown skill type '%s'" % skill_type
+            self._add_result(t, n, s)
+            if t == 'error':
+                continue
+
+            min = 1
+            if 'type' in self.snap_yaml['uses'][slot]:
+                min = 2
+            t = 'info'
+            n = self._get_check_name('attributes')
+            s = 'OK'
+            if len(self.snap_yaml['uses'][slot]) < min:
+                t = 'error'
+                s = "'%s' has no attributes" % slot
+            self._add_result(t, n, s)
+            if t == 'error':
+                continue
+
+            for attrib in self.snap_yaml['uses'][slot]:
+                if attrib == 'type':
+                    continue
+                t = 'info'
+                n = self._get_check_name('attributes', app=slot, extra=attrib)
+                s = "OK"
+                if attrib not in self.skill_types[skill_type]:
+                    t = 'error'
+                    s = "unknown attribute '%s' for type '%s'" % (attrib,
+                                                                  skill_type)
+                elif not isinstance(self.snap_yaml['uses'][slot][attrib],
+                                    type(self.skill_types[skill_type][attrib])):
+                    t = 'error'
+                    s = "'%s' is not '%s'" % \
+                        (attrib,
+                         type(self.skill_types[skill_type][attrib]).__name__)
+                self._add_result(t, n, s)
+
+    def check_apps_uses(self):
+        '''Check uses'''
+        if not self.is_snap2 or 'apps' not in self.snap_yaml:
+            return
+
+        for app in self.snap_yaml['apps']:
+            key = 'uses'
+            if key not in self.snap_yaml['apps'][app]:
+                continue
+
+            t = 'info'
+            n = self._get_check_name(key, app=app)
+            s = "OK"
+            if not isinstance(self.snap_yaml['apps'][app][key], list):
+                t = 'error'
+                s = "invalid '%s' entry: '%s' (not a list)" % (
+                    key, self.snap_yaml['apps'][app][key])
+            elif len(self.snap_yaml['apps'][app][key]) < 1:
+                t = 'error'
+                s = "invalid %s entry (empty)" % (key)
+            self._add_result(t, n, s)
+            if t == 'error':
+                continue
+
+            # The skill referenced in the app's 'uses' field can either be a
+            # known skill type (when the type name and the name of the skill is
+            # the same) or can reference a name in the snap's toplevel 'uses'
+            # mapping
+            for slot_ref in self.snap_yaml['apps'][app][key]:
+                t = 'info'
+                n = self._get_check_name('uses_slot_reference',
+                                         app=app,
+                                         extra=slot_ref)
+                s = "OK"
+                if not isinstance(slot_ref, str):
+                    t = 'error'
+                    s = "invalid slot skill name reference: '%s' (not a str)" \
+                        % slot_ref
+                elif slot_ref not in self.skill_types and \
+                        'uses' not in self.snap_yaml or \
+                        slot_ref not in self.snap_yaml['uses']:
+                    t = 'error'
+                    s = "unknown slot skill name reference '%s'" % slot_ref
+                self._add_result(t, n, s)
+
+    def check_external_symlinks(self):
+        '''Check snap for external symlinks'''
+        if not self.is_snap2:
+            return
+
+        if 'type' in self.snap_yaml and \
+                self.snap_yaml['type'] not in ['app', 'framework']:
+            return
+
+        t = 'info'
+        n = self._get_check_name('external_symlinks')
+        s = 'OK'
+        links = find_external_symlinks(self._get_unpack_dir(), self.pkg_files)
+        if len(links) > 0:
+            t = 'error'
+            s = 'package contains external symlinks: %s' % ', '.join(links)
+        self._add_result(t, n, s)
+
+    def check_architecture_all(self):
+        '''Check if actually architecture all'''
+        if not self.is_snap2:
+            return
+
+        if 'architectures' in self.snap_yaml and \
+                'all' not in self.snap_yaml['architectures']:
+            return
+
+        t = 'info'
+        n = self._get_check_name('valid_contents_for_architecture')
+        s = 'OK'
+
+        # look for compiled code
+        x_binaries = []
+        for i in self.pkg_bin_files:
+            x_binaries.append(os.path.relpath(i, self._get_unpack_dir()))
+        if len(x_binaries) > 0:
+            t = 'error'
+            s = "found binaries for architecture 'all': %s" % \
+                ", ".join(x_binaries)
+        self._add_result(t, n, s)
+
+    def check_architecture_specified_needed(self):
+        '''Check if the specified architecture is actually needed'''
+        if not self.is_snap2:
+            return
+
+        if 'architectures' in self.snap_yaml and \
+                'all' in self.snap_yaml['architectures']:
+            return
+
+        for arch in self.snap_yaml['architectures']:
+            t = 'info'
+            n = self._get_check_name('architecture_specified_needed',
+                                     extra=arch)
+            s = 'OK'
+            if len(self.pkg_bin_files) == 0:
+                t = 'warn'
+                s = "Could not find compiled binaries for architecture '%s'" \
+                    % arch
+            self._add_result(t, n, s)
+
+    def check_vcs(self):
+        '''Check for VCS files in the package'''
+        if not self.is_snap2:
+            return
+
+        t = 'info'
+        n = self._get_check_name('vcs_files')
+        s = 'OK'
+        found = []
+        for d in self.vcs_files:
+            entries = glob.glob("%s/%s" % (self._get_unpack_dir(), d))
+            if len(entries) > 0:
+                for i in entries:
+                    found.append(os.path.relpath(i, self.unpack_dir))
+        if len(found) > 0:
+            t = 'warn'
+            s = 'found VCS files in package: %s' % ", ".join(found)
+        self._add_result(t, n, s)

=== modified file 'clickreviews/sr_tests.py'
--- clickreviews/sr_tests.py	2016-02-10 19:32:10 +0000
+++ clickreviews/sr_tests.py	2016-02-11 18:32:45 +0000
@@ -15,17 +15,20 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import io
-import json
 import os
 import yaml
 
 from unittest.mock import patch
 from unittest import TestCase
+from clickreviews.common import (
+    check_results as common_check_results
+)
 
 # These should be set in the test cases
 TEST_SNAP_YAML = ""
 TEST_PKGFMT_TYPE = "snap"
 TEST_PKGFMT_VERSION = "16.04"
+TEST_UNPACK_DIR = "/fake"
 
 
 #
@@ -81,6 +84,11 @@
     return (TEST_PKGFMT_TYPE, ver)
 
 
+def __get_unpack_dir(self):
+    '''Pretend we found the unpack dir'''
+    return TEST_UNPACK_DIR
+
+
 def create_patches():
     # http://docs.python.org/3.4/library/unittest.mock-examples.html
     # Mock patching. Don't use decorators but instead patch in setUp() of the
@@ -116,6 +124,10 @@
         'clickreviews.common.Review._check_innerpath_executable',
         _check_innerpath_executable))
 
+    #  sr_common
+    patches.append(patch('clickreviews.sr_common.SnapReview._get_unpack_dir',
+                   __get_unpack_dir))
+
     # pkgfmt
     patches.append(patch("clickreviews.sr_common.SnapReview._pkgfmt_type",
                    _pkgfmt_type))
@@ -133,7 +145,6 @@
         self._reset_test_data()
 
     def _reset_test_data(self):
-        # dictionary representing DEBIAN/control
         self.test_snap_yaml = dict()
         self.set_test_pkgfmt("snap", "16.04")
 
@@ -162,43 +173,10 @@
             self.test_snap_yaml["version"],
             self.test_snap_yaml["architectures"][0])
 
-    #
-    # check_results(report, expected_counts, expected)
-    # Verify exact counts of types
-    #   expected_counts={'info': 1, 'warn': 0, 'error': 0}
-    #   self.check_results(report, expected_counts)
-    # Verify counts of warn and error types
-    #   expected_counts={'info': None, 'warn': 0, 'error': 0}
-    #   self.check_results(report, expected_counts)
-    # Verify exact messages:
-    #   expected = dict()
-    #   expected['info'] = dict()
-    #   expected['warn'] = dict()
-    #   expected['warn']['skeleton_baz'] = "TODO"
-    #   expected['error'] = dict()
-    #   self.check_results(r, expected=expected)
-    #
     def check_results(self, report,
                       expected_counts={'info': 1, 'warn': 0, 'error': 0},
                       expected=None):
-        if expected is not None:
-            for t in expected.keys():
-                for r in expected[t]:
-                    self.assertTrue(r in report[t],
-                                    "Could not find '%s' (%s) in:\n%s" %
-                                    (r, t, json.dumps(report, indent=2)))
-                    for k in expected[t][r]:
-                        self.assertTrue(k in report[t][r],
-                                        "Could not find '%s' (%s) in:\n%s" %
-                                        (k, r, json.dumps(report, indent=2)))
-                    self.assertEqual(expected[t][r][k], report[t][r][k])
-        else:
-            for k in expected_counts.keys():
-                if expected_counts[k] is None:
-                    continue
-                self.assertEqual(len(report[k]), expected_counts[k],
-                                 "(%s not equal)\n%s" %
-                                 (k, json.dumps(report, indent=2)))
+        common_check_results(self, report, expected_counts, expected)
 
     def check_manual_review(self, report, check_name,
                             result_type='error', manual_review=True):
@@ -221,6 +199,10 @@
         TEST_PKGFMT_TYPE = t
         TEST_PKGFMT_VERSION = v
 
+    def set_test_unpack_dir(self, d):
+        global TEST_UNPACK_DIR
+        TEST_UNPACK_DIR = d
+
     def setUp(self):
         '''Make sure our patches are applied everywhere'''
         patches = create_patches()
@@ -236,5 +218,7 @@
         TEST_PKGFMT_TYPE = "snap"
         global TEST_PKGFMT_VERSION
         TEST_PKGFMT_VERSION = "16.04"
+        global TEST_UNPACK_DIR
+        TEST_UNPACK_DIR = "/fake"
 
         self._reset_test_data()

=== modified file 'clickreviews/tests/test_cr_lint.py'
--- clickreviews/tests/test_cr_lint.py	2016-02-09 21:45:25 +0000
+++ clickreviews/tests/test_cr_lint.py	2016-02-11 18:32:45 +0000
@@ -1940,8 +1940,8 @@
         return tmp_dir
 
     def test_check_dot_click_root(self):
-        package = utils.make_package(extra_files=['.click/'],
-                                     output_dir=self.mkdtemp())
+        package = utils.make_click(extra_files=['.click/'],
+                                   output_dir=self.mkdtemp())
         c = ClickReviewLint(package)
 
         c.check_dot_click()

=== added file 'clickreviews/tests/test_sr_lint.py'
--- clickreviews/tests/test_sr_lint.py	1970-01-01 00:00:00 +0000
+++ clickreviews/tests/test_sr_lint.py	2016-02-11 18:32:45 +0000
@@ -0,0 +1,2396 @@
+'''test_sr_lint.py: tests for the sr_lint module'''
+#
+# Copyright (C) 2013-2016 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from unittest.mock import patch
+from unittest import TestCase
+import os
+import shutil
+import tempfile
+
+from clickreviews.common import cleanup_unpack
+from clickreviews.common import check_results as common_check_results
+from clickreviews.sr_lint import SnapReviewLint
+import clickreviews.sr_tests as sr_tests
+from clickreviews.tests import utils
+
+
+class TestSnapReviewLint(sr_tests.TestSnapReview):
+    """Tests for the lint review tool."""
+    def setUp(self):
+        '''Make sure we are snap v2'''
+        super().setUp()
+        self.set_test_pkgfmt("snap", "16.04")
+
+    def _create_ports(self):
+        ports = {'internal': {'int1': {"port": '8081/tcp', "negotiable": True}},
+                 'external': {'ext1': {"port": '80/tcp', "negotiable": False},
+                              'ext2': {"port": '88/udp'}
+                              }
+                 }
+        return ports
+
+    def _create_top_uses(self):
+        uses = {'skill-caps': {'type': 'migration-skill',
+                               'caps': ['network-client']},
+                'skill-override': {'type': 'migration-skill',
+                                   'security-override': {"read_path": "/foo/",
+                                                         "seccomp": "abc"}},
+                'skill-policy': {'type': 'migration-skill',
+                                 'security-policy': {"apparmor": "meta/aa",
+                                                     "seccomp": "meta/sc"}},
+                'skill-template': {'type': 'migration-skill',
+                                   'security-template': "unconfined"}
+                }
+        return uses
+
+    def _create_apps_uses(self):
+        uses = {'app1': {'uses': ['skill-caps']},
+                'app2': {'uses': ['skill-caps', 'skill-template']},
+                'app3': {'uses': ['skill-template', 'skill-override']},
+                'app4': {'uses': ['skill-policy']},
+                }
+        return uses
+
+    def patch_frameworks(self):
+        def _mock_frameworks(self, overrides=None):
+            self.FRAMEWORKS = {
+                'docker-1.3': 'obsolete',
+                'docker': 'available',
+                'hello-dbus-fwk': 'available',
+                'some-fwk': 'deprecated',
+            }
+            self.AVAILABLE_FRAMEWORKS = ['docker', 'hello-dbus-fwk']
+            self.OBSOLETE_FRAMEWORKS = ['docker-1.3']
+            self.DEPRECATED_FRAMEWORKS = ['some-fwk']
+        p = patch('clickreviews.frameworks.Frameworks.__init__',
+                  _mock_frameworks)
+        p.start()
+        self.addCleanup(p.stop)
+
+    def test_all_checks_as_v2(self):
+        '''Test snap v2 has checks'''
+        self.set_test_pkgfmt("snap", "16.04")
+        c = SnapReviewLint(self.test_name)
+        c.do_checks()
+        sum = 0
+        for i in c.click_report:
+            sum += len(c.click_report[i])
+        self.assertTrue(sum != 0)
+
+    def test_all_checks_as_v1(self):
+        '''Test snap v1 has no checks'''
+        self.set_test_pkgfmt("snap", "15.04")
+        c = SnapReviewLint(self.test_name)
+        c.do_checks()
+        sum = 0
+        for i in c.click_report:
+            sum += len(c.click_report[i])
+        self.assertTrue(sum == 0)
+
+    def test_all_checks_as_click(self):
+        '''Test click format has no checks'''
+        self.set_test_pkgfmt("click", "0.4")
+        c = SnapReviewLint(self.test_name)
+        c.do_checks()
+        sum = 0
+        for i in c.click_report:
+            sum += len(c.click_report[i])
+        self.assertTrue(sum == 0)
+
+    def test_check_frameworks_none(self):
+        '''Test check_frameworks() - none'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_frameworks_empty(self):
+        '''Test check_frameworks() - empty'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_frameworks_multiple(self):
+        '''Test check_frameworks() - multiple'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", ['docker', 'hello-dbus-fwk'])
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_frameworks_bad(self):
+        '''Test check_frameworks() - bad'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", "bad")
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_frameworks_nonexistent(self):
+        '''Test check_frameworks() - nonexistent'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", ["nonexistent"])
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_frameworks_deprecated(self):
+        '''Test check_frameworks() - deprecated'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", ["some-fwk"])
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 1, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_frameworks_obsolete(self):
+        '''Test check_frameworks() - obsolete'''
+        self.patch_frameworks()
+        self.set_test_snap_yaml("frameworks", ["docker-1.3"])
+        c = SnapReviewLint(self.test_name)
+        c.check_frameworks()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_toplevel(self):
+        '''Test check_name - toplevel'''
+        self.set_test_snap_yaml("name", "foo")
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_flat(self):
+        '''Test check_name - obsoleted flat'''
+        self.set_test_snap_yaml("name", "foo.bar")
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_reverse_domain(self):
+        '''Test check_name - obsoleted reverse domain'''
+        self.set_test_snap_yaml("name", "com.ubuntu.develeper.baz.foo")
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_bad(self):
+        '''Test check_name - bad'''
+        self.set_test_snap_yaml("name", "foo?bar")
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_bad2(self):
+        '''Test check_name - empty'''
+        self.set_test_snap_yaml("name", "")
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_bad3(self):
+        '''Test check_name - list'''
+        self.set_test_snap_yaml("name", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_bad4(self):
+        '''Test check_name - dict'''
+        self.set_test_snap_yaml("name", {})
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_name_missing(self):
+        '''Test check_name - missing'''
+        self.set_test_snap_yaml("name", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_name()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_version(self):
+        '''Test check_version'''
+        self.set_test_snap_yaml("version", 1)
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_version1(self):
+        '''Test check_version - integer'''
+        self.set_test_snap_yaml("version", 1)
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_version2(self):
+        '''Test check_version - float'''
+        self.set_test_snap_yaml("version", 1.0)
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_version3(self):
+        '''Test check_version - MAJOR.MINOR.MICRO'''
+        self.set_test_snap_yaml("version", "1.0.1")
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_version4(self):
+        '''Test check_version - str'''
+        self.set_test_snap_yaml("version", "1.0a")
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_version5(self):
+        '''Test check_version - alpha'''
+        self.set_test_snap_yaml("version", "a.b")
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_version_bad(self):
+        '''Test check_version - bad'''
+        self.set_test_snap_yaml("version", "foo?bar")
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_version_bad2(self):
+        '''Test check_version - empty'''
+        self.set_test_snap_yaml("version", "")
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_version_bad3(self):
+        '''Test check_version - list'''
+        self.set_test_snap_yaml("version", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_version_bad4(self):
+        '''Test check_version - dict'''
+        self.set_test_snap_yaml("version", {})
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_version_missing(self):
+        '''Test check_version - missing'''
+        self.set_test_snap_yaml("version", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_type(self):
+        '''Test check_type - unspecified'''
+        self.set_test_snap_yaml("type", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_type()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_app(self):
+        '''Test check_type - app'''
+        self.set_test_snap_yaml("type", "app")
+        c = SnapReviewLint(self.test_name)
+        c.check_type()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_framework(self):
+        '''Test check_type - framework'''
+        self.set_test_snap_yaml("type", "framework")
+        c = SnapReviewLint(self.test_name)
+        c.check_type()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_redflagged(self):
+        '''Test check_type_redflagged - unspecified'''
+        self.set_test_snap_yaml("type", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_type_redflagged()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_redflagged_app(self):
+        '''Test check_type_redflagged - app'''
+        self.set_test_snap_yaml("type", "app")
+        c = SnapReviewLint(self.test_name)
+        c.check_type_redflagged()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_redflagged_framework(self):
+        '''Test check_type_redflagged - framework'''
+        self.set_test_snap_yaml("type", "framework")
+        c = SnapReviewLint(self.test_name)
+        c.check_type_redflagged()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_redflagged_gadget(self):
+        '''Test check_type_redflagged - gadget'''
+        self.set_test_snap_yaml("type", "gadget")
+        c = SnapReviewLint(self.test_name)
+        c.check_type_redflagged()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_redflagged_kernel(self):
+        '''Test check_type_redflagged - kernel'''
+        self.set_test_snap_yaml("type", "kernel")
+        c = SnapReviewLint(self.test_name)
+        c.check_type_redflagged()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_redflagged_os(self):
+        '''Test check_type_redflagged - os'''
+        self.set_test_snap_yaml("type", "os")
+        c = SnapReviewLint(self.test_name)
+        c.check_type_redflagged()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_type_unknown(self):
+        '''Test check_type - unknown'''
+        self.set_test_snap_yaml("type", "nonexistent")
+        c = SnapReviewLint(self.test_name)
+        c.check_type()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_icon(self):
+        '''Test check_icon()'''
+        self.set_test_snap_yaml("icon", "someicon")
+        self.set_test_snap_yaml("type", "gadget")
+        self.set_test_unpack_dir = "/nonexistent"
+        c = SnapReviewLint(self.test_name)
+        c.pkg_files.append(os.path.join(c._get_unpack_dir(), 'someicon'))
+        c.check_icon()
+        r = c.click_report
+        expected_counts = {'info': 4, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_icon_no_gadget(self):
+        '''Test check_icon() - no gadget'''
+        self.set_test_snap_yaml("icon", "someicon")
+        self.set_test_unpack_dir = "/nonexistent"
+        c = SnapReviewLint(self.test_name)
+        c.pkg_files.append(os.path.join(c._get_unpack_dir(), 'someicon'))
+        c.check_icon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 1, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_icon_unspecified(self):
+        '''Test check_icon() - unspecified'''
+        self.set_test_snap_yaml("icon", None)
+        self.set_test_snap_yaml("type", "gadget")
+        c = SnapReviewLint(self.test_name)
+        c.check_icon()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_icon_empty(self):
+        '''Test check_icon() - empty'''
+        self.set_test_snap_yaml("icon", "")
+        self.set_test_snap_yaml("type", "gadget")
+        c = SnapReviewLint(self.test_name)
+        c.check_icon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_icon_absolute_path(self):
+        '''Test check_icon() - absolute path'''
+        self.set_test_snap_yaml("icon", "/foo/bar/someicon")
+        self.set_test_snap_yaml("type", "gadget")
+        c = SnapReviewLint(self.test_name)
+        c.pkg_files.append('/foo/bar/someicon')
+        c.check_icon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_icon_missing(self):
+        '''Test check_icon() - missing icon'''
+        self.set_test_snap_yaml("icon", "someicon")
+        self.set_test_snap_yaml("type", "gadget")
+        self.set_test_unpack_dir = "/nonexistent"
+        c = SnapReviewLint(self.test_name)
+        # since the icon isn't in c.pkg_files, don't add it for this test
+        # c.pkg_files.append(os.path.join(c._get_unpack_dir(), 'someicon'))
+        c.check_icon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_bad(self):
+        '''Test check_architectures() - bad (dict)'''
+        self.set_test_snap_yaml("architectures", {})
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_missing(self):
+        '''Test check_architectures() (missing)'''
+        self.set_test_snap_yaml("architectures", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_all(self):
+        '''Test check_architectures() (all)'''
+        self.set_test_snap_yaml("architectures", ["all"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_single_armhf(self):
+        '''Test check_architectures() (single arch, armhf)'''
+        self.set_test_snap_yaml("architectures", ["armhf"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_single_arm64(self):
+        '''Test check_architectures() (single arch, arm64)'''
+        self.set_test_snap_yaml("architectures", ["arm64"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_single_i386(self):
+        '''Test check_architectures() (single arch, i386)'''
+        self.set_test_snap_yaml("architectures", ["i386"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_single_amd64(self):
+        '''Test check_architectures() (single arch, amd64)'''
+        self.set_test_snap_yaml("architectures", ["amd64"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architectures_single_nonexistent(self):
+        '''Test check_architectures() (single nonexistent arch)'''
+        self.set_test_snap_yaml("architectures", ["nonexistent"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_snappy_valid_arch_multi(self):
+        '''Test check_architectures() (valid multi)'''
+        self.set_test_snap_yaml("architectures", ["amd64", "armhf"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_snappy_valid_arch_multi2(self):
+        '''Test check_architectures() (valid multi2)'''
+        self.set_test_snap_yaml("architectures", ["armhf", "arm64", "i386"])
+        c = SnapReviewLint(self.test_name)
+        c.check_architectures()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_unknown_entries(self):
+        '''Test check_unknown_entries - none'''
+        c = SnapReviewLint(self.test_name)
+        c.check_unknown_entries()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_unknown_entries2(self):
+        '''Test check_unknown_entries - one'''
+        self.set_test_snap_yaml("nonexistent", "bar")
+        c = SnapReviewLint(self.test_name)
+        c.check_unknown_entries()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 1, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_config(self):
+        '''Test check_config()'''
+        c = SnapReviewLint(self.test_name)
+        self.set_test_unpack_dir("/nonexistent")
+        c.pkg_files.append(os.path.join(c._get_unpack_dir(),
+                           'meta/hooks/config'))
+        c.check_config()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_config_nonexecutable(self):
+        '''Test check_config() - not executable'''
+        c = SnapReviewLint(self.test_name)
+        self.set_test_unpack_dir("/nonexistent.nonexec")
+        c.pkg_files.append(os.path.join(c._get_unpack_dir(),
+                           'meta/hooks/config'))
+        c.check_config()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_description(self):
+        '''Test check_description'''
+        self.set_test_snap_yaml("description", "This is a test description")
+        c = SnapReviewLint(self.test_name)
+        c.check_description()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_description_missing(self):
+        '''Test check_description - not present'''
+        self.set_test_snap_yaml("description", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_description()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_description_bad(self):
+        '''Test check_description - short'''
+        self.set_test_snap_yaml("description", "a")
+        c = SnapReviewLint(self.test_name)
+        c.check_description()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_description_bad2(self):
+        '''Test check_description - empty'''
+        self.set_test_snap_yaml("description", "")
+        c = SnapReviewLint(self.test_name)
+        c.check_description()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_description_bad3(self):
+        '''Test check_description - list'''
+        self.set_test_snap_yaml("description", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_description()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_agreement(self):
+        '''Test check_license_agreement'''
+        self.set_test_snap_yaml("license-agreement",
+                                "This is a test license_agreement")
+        c = SnapReviewLint(self.test_name)
+        c.check_license_agreement()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_agreement_missing(self):
+        '''Test check_license_agreement - not present'''
+        self.set_test_snap_yaml("license-agreement", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_license_agreement()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_agreement_bad(self):
+        '''Test check_license_agreement - empty'''
+        self.set_test_snap_yaml("license-agreement", "")
+        c = SnapReviewLint(self.test_name)
+        c.check_license_agreement()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_agreement_bad2(self):
+        '''Test check_license_agreement - list'''
+        self.set_test_snap_yaml("license-agreement", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_license_agreement()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_version(self):
+        '''Test check_license_version'''
+        self.set_test_snap_yaml("license-version",
+                                "This is a test license_version")
+        c = SnapReviewLint(self.test_name)
+        c.check_license_version()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_version_missing(self):
+        '''Test check_license_version - not present'''
+        self.set_test_snap_yaml("license-version", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_license_version()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_version_bad(self):
+        '''Test check_license_version - empty'''
+        self.set_test_snap_yaml("license-version", "")
+        c = SnapReviewLint(self.test_name)
+        c.check_license_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_license_version_bad2(self):
+        '''Test check_license_version - list'''
+        self.set_test_snap_yaml("license-version", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_license_version()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_summary(self):
+        '''Test check_summary'''
+        self.set_test_snap_yaml("summary", "This is a test summary")
+        c = SnapReviewLint(self.test_name)
+        c.check_summary()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_summary_missing(self):
+        '''Test check_summary - not present'''
+        self.set_test_snap_yaml("summary", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_summary()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_summary_bad(self):
+        '''Test check_summary - short'''
+        self.set_test_snap_yaml("summary", "a")
+        c = SnapReviewLint(self.test_name)
+        c.check_summary()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_summary_bad2(self):
+        '''Test check_summary - empty'''
+        self.set_test_snap_yaml("summary", "")
+        c = SnapReviewLint(self.test_name)
+        c.check_summary()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_summary_bad3(self):
+        '''Test check_summary - list'''
+        self.set_test_snap_yaml("summary", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_summary()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_one_command(self):
+        '''Test check_apps() - one command'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/foo"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': 5, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_one_daemon(self):
+        '''Test check_apps() - one daemon'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/foo",
+                                                 "daemon": "single"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': 5, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_two_commands(self):
+        '''Test check_apps() - two commands'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/foo"},
+                                         "bar": {"command": "bin/bar"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': 8, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_command_plus_daemon(self):
+        '''Test check_apps() - command and daemon'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/foo"},
+                                         "bar": {"command": "bin/bar",
+                                                 "daemon": "single"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': 8, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_two_daemons(self):
+        '''Test check_apps() - command and daemon'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/foo",
+                                                 "daemon": "single"},
+                                         "bar": {"command": "bin/bar",
+                                                 "daemon": "single"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': 8, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_missing(self):
+        '''Test check_apps() - missing'''
+        self.set_test_snap_yaml("apps", None)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_bad(self):
+        '''Test check_apps() - bad'''
+        self.set_test_snap_yaml("apps", [])
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_bad2(self):
+        '''Test check_apps() - empty'''
+        self.set_test_snap_yaml("apps", {})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_bad3(self):
+        '''Test check_apps() - missing command'''
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": "single"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_bad4(self):
+        '''Test check_apps() - unknown field'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/foo",
+                                                 "nonexistent": "abc"},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 1, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_bad5(self):
+        '''Test check_apps() - invalid field'''
+        self.set_test_snap_yaml("apps", {"foo": []})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_bad6(self):
+        '''Test check_apps() - empty fields'''
+        self.set_test_snap_yaml("apps", {"foo": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_command(self):
+        '''Test check_apps_command()'''
+        cmd = "bin/foo"
+        self.set_test_snap_yaml("apps", {"foo": {"command": cmd},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.pkg_files.append(os.path.join('/fake', cmd))
+        c.check_apps_command()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_command_missing(self):
+        '''Test check_apps_command() - missing'''
+        self.set_test_snap_yaml("apps", {"foo": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_command()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_command_empty(self):
+        '''Test check_apps_command() - empty'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": ""},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_command()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_command_invalid(self):
+        '''Test check_apps_command() - list'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": []},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_command()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_command_nonexistent(self):
+        '''Test check_apps_command() - nonexistent'''
+        cmd = "bin/foo"
+        self.set_test_snap_yaml("apps", {"foo": {"command": cmd},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_command()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop(self):
+        '''Test check_apps_stop()'''
+        cmd = "bin/foo"
+        self.set_test_snap_yaml("apps", {"foo": {"stop": cmd},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.pkg_files.append(os.path.join('/fake', cmd))
+        c.check_apps_stop()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_missing(self):
+        '''Test check_apps_stop() - missing'''
+        self.set_test_snap_yaml("apps", {"foo": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_empty(self):
+        '''Test check_apps_stop() - empty'''
+        self.set_test_snap_yaml("apps", {"foo": {"stop": ""},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_invalid(self):
+        '''Test check_apps_stop() - list'''
+        self.set_test_snap_yaml("apps", {"foo": {"stop": []},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_nonexistent(self):
+        '''Test check_apps_stop() - nonexistent'''
+        cmd = "bin/foo"
+        self.set_test_snap_yaml("apps", {"foo": {"stop": cmd},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_poststop(self):
+        '''Test check_apps_poststop()'''
+        cmd = "bin/foo"
+        self.set_test_snap_yaml("apps", {"foo": {"poststop": cmd},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.pkg_files.append(os.path.join('/fake', cmd))
+        c.check_apps_poststop()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_poststop_missing(self):
+        '''Test check_apps_poststop() - missing'''
+        self.set_test_snap_yaml("apps", {"foo": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_poststop()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_poststop_empty(self):
+        '''Test check_apps_poststop() - empty'''
+        self.set_test_snap_yaml("apps", {"foo": {"poststop": ""},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_poststop()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_poststop_invalid(self):
+        '''Test check_apps_poststop() - list'''
+        self.set_test_snap_yaml("apps", {"foo": {"poststop": []},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_poststop()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_poststop_nonexistent(self):
+        '''Test check_apps_poststop() - nonexistent'''
+        cmd = "bin/foo"
+        self.set_test_snap_yaml("apps", {"foo": {"poststop": cmd},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_poststop()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_simple(self):
+        '''Test check_apps_daemon() - simple'''
+        entry = "simple"
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_forking(self):
+        '''Test check_apps_daemon() - forking'''
+        entry = "forking"
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_oneshot(self):
+        '''Test check_apps_daemon() - oneshot'''
+        entry = "oneshot"
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_dbus(self):
+        '''Test check_apps_daemon() - dbus'''
+        entry = "dbus"
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_missing(self):
+        '''Test check_apps_daemon() - missing'''
+        self.set_test_snap_yaml("apps", {"foo": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_empty(self):
+        '''Test check_apps_daemon() - empty'''
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": ""},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_invalid(self):
+        '''Test check_apps_daemon() - list'''
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": []},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_daemon_nonexistent(self):
+        '''Test check_apps_daemon() - nonexistent'''
+        entry = "nonexistent"
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_daemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon(self):
+        '''Test check_apps_nondaemon()'''
+        entry = "simple"
+        self.set_test_snap_yaml("apps", {"foo": {"daemon": entry,
+                                                 "stop": "bin/bar"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_command(self):
+        '''Test check_apps_nondaemon() - command'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_uses(self):
+        '''Test check_apps_nondaemon() - uses'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "uses": {}}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_stop(self):
+        '''Test check_apps_nondaemon() - stop'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "stop": "bin/bar"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_stop_timeout(self):
+        '''Test check_apps_nondaemon() - stop-timeout'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "stop-timeout": 60}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_restart_condition(self):
+        '''Test check_apps_nondaemon() - restart-condition'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "restart-condition":
+                                                 "never"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_poststop(self):
+        '''Test check_apps_nondaemon() - poststop'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "poststop": "bin/bar"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_ports(self):
+        '''Test check_apps_nondaemon() - ports'''
+        ports = self._create_ports()
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_bus_name(self):
+        '''Test check_apps_nondaemon() - bus-name'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "bus-name": "tld.foo"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_socket(self):
+        '''Test check_apps_nondaemon() - socket'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "socket": True}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_listen_stream(self):
+        '''Test check_apps_nondaemon() - listen-stream'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "listen-stream": "@bar"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_socket_user(self):
+        '''Test check_apps_nondaemon() - socket-user'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "socket-user": "docker"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_nondaemon_socket_group(self):
+        '''Test check_apps_nondaemon() - socket-group'''
+        self.set_test_snap_yaml("apps", {"foo": {"command": "bin/bar",
+                                                 "socket-group": "docker"}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_nondaemon()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_always(self):
+        '''Test check_apps_restart-condition() - always'''
+        entry = "always"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_never(self):
+        '''Test check_apps_restart-condition() - never'''
+        entry = "never"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_on_abnormal(self):
+        '''Test check_apps_restart-condition() - on-abnormal'''
+        entry = "on-abnormal"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_on_abort(self):
+        '''Test check_apps_restart-condition() - on-abort'''
+        entry = "on-abort"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_on_failure(self):
+        '''Test check_apps_restart-condition() - on-failure'''
+        entry = "on-failure"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_on_success(self):
+        '''Test check_apps_restart-condition() - on-success'''
+        entry = "on-success"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_missing(self):
+        '''Test check_apps_restart-condition() - missing'''
+        self.set_test_snap_yaml("apps", {"foo": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_empty(self):
+        '''Test check_apps_restart-condition() - empty'''
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": ""},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_invalid(self):
+        '''Test check_apps_restart-condition() - list'''
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": []},
+                                         })
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_restart_condition_nonexistent(self):
+        '''Test check_apps_restart-condition() - nonexistent'''
+        entry = "nonexistent"
+        self.set_test_snap_yaml("apps", {"foo": {"restart-condition": entry}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_restart_condition()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_pkgname(self):
+        '''Test check_apps_busname() - pkgname'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": name}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': 3, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_appname(self):
+        '''Test check_apps_busname() - appname'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": "%s.bar" % name}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': 3, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_missing_framework_app(self):
+        '''Test check_apps_busname() - missing framework (app)'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": "%s.bar" % name}})
+        self.set_test_snap_yaml("type", 'app')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_missing_framework_gadget(self):
+        '''Test check_apps_busname() - missing framework (gadget)'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": "%s.bar" % name}})
+        self.set_test_snap_yaml("type", 'gadget')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_missing_framework_kernel(self):
+        '''Test check_apps_busname() - missing framework (kernel)'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": name}})
+        self.set_test_snap_yaml("type", 'kernel')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_pkgname_bad(self):
+        '''Test check_apps_busname() - bad pkgname'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": "%s-bad" % name}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_appname_bad(self):
+        '''Test check_apps_busname() - bad appname'''
+        name = "tld.%s" % self.test_name.split('_')[0].split('.')[0]
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name":
+                                "%s.bar-bad" % name}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_empty(self):
+        '''Test check_apps_busname() - bad (empty)'''
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": ""}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_invalid(self):
+        '''Test check_apps_busname() - bad (invalid)'''
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": []}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_busname_bad_regex(self):
+        '''Test check_apps_busname() - bad (regex)'''
+        self.set_test_snap_yaml("apps", {"bar": {"bus-name": "name$"}})
+        self.set_test_snap_yaml("type", 'framework')
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_busname()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports(self):
+        '''Test check_apps_ports()'''
+        ports = self._create_ports()
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': 7, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_internal(self):
+        '''Test check_apps_ports() - internal'''
+        ports = self._create_ports()
+        del ports['external']
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': 3, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_external(self):
+        '''Test check_apps_ports() - external'''
+        ports = self._create_ports()
+        del ports['internal']
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': 5, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_empty(self):
+        '''Test check_apps_ports() - empty'''
+        self.set_test_snap_yaml("apps", {"bar": {"ports": {}}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid(self):
+        '''Test check_apps_ports() - invalid'''
+        self.set_test_snap_yaml("apps", {"bar": {"ports": []}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_bad_key(self):
+        '''Test check_apps_ports() - bad key'''
+        ports = self._create_ports()
+        ports['xternal'] = ports['external']
+        del ports['external']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_missing_internal(self):
+        '''Test check_apps_ports() - missing internal'''
+        ports = self._create_ports()
+        del ports['internal']['int1']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_missing_external(self):
+        '''Test check_apps_ports() - missing external'''
+        ports = self._create_ports()
+        del ports['external']['ext1']
+        del ports['external']['ext2']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_missing_external_subkey(self):
+        '''Test check_apps_ports() - missing external subkey'''
+        ports = self._create_ports()
+        del ports['external']['ext2']['port']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_missing_internal_subkey(self):
+        '''Test check_apps_ports() - missing internal subkey'''
+        ports = self._create_ports()
+        del ports['internal']['int1']['port']
+        del ports['internal']['int1']['negotiable']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_missing_internal_port_subkey(self):
+        '''Test check_apps_ports() - missing internal port subkey'''
+        ports = self._create_ports()
+        del ports['internal']['int1']['port']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': 7, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_internal_subkey(self):
+        '''Test check_apps_ports() - invalid internal subkey'''
+        ports = self._create_ports()
+        ports['internal']['int1']['prt'] = ports['internal']['int1']['port']
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_internal_port(self):
+        '''Test check_apps_ports() - invalid internal port'''
+        ports = self._create_ports()
+        ports['internal']['int1']['port'] = "bad/8080"
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_external_port(self):
+        '''Test check_apps_ports() - invalid external port'''
+        ports = self._create_ports()
+        ports['external']['ext2']['port'] = []
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_internal_low_port(self):
+        '''Test check_apps_ports() - invalid internal low port'''
+        ports = self._create_ports()
+        ports['internal']['int1']['port'] = "0/tcp"
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_internal_high_port(self):
+        '''Test check_apps_ports() - invalid internal high port'''
+        ports = self._create_ports()
+        ports['internal']['int1']['port'] = "65536/tcp"
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_internal_negotiable(self):
+        '''Test check_apps_ports() - invalid internal negotiable'''
+        ports = self._create_ports()
+        ports['internal']['int1']['negotiable'] = -99999999
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_ports_invalid_internal_negotiable2(self):
+        '''Test check_apps_ports() - invalid internal negotiable'''
+        ports = self._create_ports()
+        ports['internal']['int1']['negotiable'] = []
+
+        self.set_test_snap_yaml("apps", {"bar": {"ports": ports}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_ports()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout(self):
+        '''Test check_apps_stop_timeout()'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": 30}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_nonexistent(self):
+        '''Test check_apps_stop_timeout_nonexistent()'''
+        self.set_test_snap_yaml("apps", {"bar": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_granularity(self):
+        '''Test check_apps_stop_timeout()'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": '30s'}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_empty(self):
+        '''Test check_apps_stop_timeout() - empty'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": ''}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_bad(self):
+        '''Test check_apps_stop_timeout() - bad'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": 'a'}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_bad2(self):
+        '''Test check_apps_stop_timeout() - bad (list)'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": []}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_bad_granularity(self):
+        '''Test check_apps_stop_timeout() - bad with granularity'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": '30a'}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_range_low(self):
+        '''Test check_apps_stop_timeout() - out of range (low)'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": -1}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_stop_timeout_range_high(self):
+        '''Test check_apps_stop_timeout() - out of range (high)'''
+        self.set_test_snap_yaml("apps", {"bar": {"stop-timeout": 61}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_stop_timeout()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket(self):
+        '''Test check_apps_socket()'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket": True,
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_path(self):
+        '''Test check_apps_listen_stream() - path'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream":
+                                                 "/tmp/%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_no_listen_stream(self):
+        '''Test check_apps_socket() - missing listen-stream'''
+        self.set_test_snap_yaml("apps", {"bar": {"socket": True}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_bad(self):
+        '''Test check_apps_socket() - bad'''
+        self.set_test_snap_yaml("apps", {"bar": {"socket": ""}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_nonexistent(self):
+        '''Test check_apps_socket() - nonexistent'''
+        self.set_test_snap_yaml("apps", {"bar": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_abspkgname(self):
+        '''Test check_apps_listen_stream() - @pkgname'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_abspkgname2(self):
+        '''Test check_apps_listen_stream() - @pkgname_'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream":
+                                                 "@%s_something" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_nonexistent(self):
+        '''Test check_apps_listen_stream() - nonexistent'''
+        self.set_test_snap_yaml("apps", {"bar": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_bad(self):
+        '''Test check_apps_listen_stream() - bad (list)'''
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream": []}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_bad_abstract(self):
+        '''Test check_apps_listen_stream() - bad (wrong name)'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream":
+                                                 "@%s/nomatch" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_bad_relative(self):
+        '''Test check_apps_listen_stream() - bad (not / or @)'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream": name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_bad_path(self):
+        '''Test check_apps_listen_stream() - bad path'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream":
+                                                 "/var/log/%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_listen_stream_empty(self):
+        '''Test check_apps_listen_stream() - empty'''
+        self.set_test_snap_yaml("apps", {"bar": {"listen-stream": ""}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_listen_stream()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_user(self):
+        '''Test check_apps_socket_user()'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-user": name,
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_user()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_user_no_listen_stream(self):
+        '''Test check_apps_socket_user() - missing listen-stream'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-user": name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_user()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_user_bad(self):
+        '''Test check_apps_socket_user() - bad user'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-user": name + "-no",
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_user()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 2}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_user_bad2(self):
+        '''Test check_apps_socket_user() - bad (list)'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-user": [],
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_user()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_user_empty(self):
+        '''Test check_apps_socket_user() - empty'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-user": "",
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_user()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_user_nonexistent(self):
+        '''Test check_apps_socket_user() - nonexistent'''
+        self.set_test_snap_yaml("apps", {"bar": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_user()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_group(self):
+        '''Test check_apps_socket_group()'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-group": name,
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_group()
+        r = c.click_report
+        expected_counts = {'info': 2, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_group_no_listen_stream(self):
+        '''Test check_apps_socket_group() - missing listen-stream'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-group": name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_group()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_group_bad(self):
+        '''Test check_apps_socket_group() - bad group'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-group": name + "-no",
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_group()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 2}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_group_bad2(self):
+        '''Test check_apps_socket_group() - bad (list)'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-group": [],
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_group()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_group_empty(self):
+        '''Test check_apps_socket_group() - empty'''
+        name = self.test_snap_yaml['name']
+        self.set_test_snap_yaml("apps", {"bar": {"socket-group": "",
+                                                 "listen-stream":
+                                                 "@%s" % name}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_group()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_socket_group_nonexistent(self):
+        '''Test check_apps_socket_group() - nonexistent'''
+        self.set_test_snap_yaml("apps", {"bar": {}})
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_socket_group()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses(self):
+        '''Test check_uses()'''
+        uses = self._create_top_uses()
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': 13, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_bad_type(self):
+        '''Test check_uses() - bad type (list)'''
+        uses = {'skill-caps': {'type': [],
+                               'caps': ['network-client']}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_empty_type(self):
+        '''Test check_uses() - empty type'''
+        uses = {'skill-caps': {'type': "",
+                               'caps': ['network-client']}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_unspecified_type(self):
+        '''Test check_uses() - unspecified type'''
+        uses = {'migration-skill': {'caps': ['network-client']}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': 3, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_unknown_type(self):
+        '''Test check_uses() - type (unknown)'''
+        uses = {'skill-caps': {'type': 'nonexistent',
+                               'caps': ['network-client']}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_unspecified_unknown_type(self):
+        '''Test check_uses() - unspecified type (unknown)'''
+        uses = {'nonexistent': {'caps': ['network-client']}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_missing_attrib(self):
+        '''Test check_uses() - missing attrib'''
+        uses = {'migration-skill': {}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_missing_attrib_explicit_type(self):
+        '''Test check_uses() - missing attrib'''
+        uses = {'skill-caps': {'type': 'migration-skill'}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_unknown_attrib(self):
+        '''Test check_uses() - unknown attrib'''
+        uses = {'skill-caps': {'type': "migration-skill",
+                               'nonexistent': 'abc'}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_bad_attrib_caps(self):
+        '''Test check_uses() - bad attrib - caps'''
+        uses = {'skill-caps': {'type': "migration-skill",
+                               'caps': 'bad'}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_bad_attrib_security_override(self):
+        '''Test check_uses() - bad attrib - security-override'''
+        uses = {'skill-caps': {'type': "migration-skill",
+                               'security-override': 'bad'}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_bad_attrib_security_policy(self):
+        '''Test check_uses() - bad attrib - security-policy'''
+        uses = {'skill-caps': {'type': "migration-skill",
+                               'security-policy': 'bad'}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_uses_bad_attrib_security_template(self):
+        '''Test check_uses() - bad attrib - security-template'''
+        uses = {'skill-caps': {'type': "migration-skill",
+                               'security-template': []}}
+        self.set_test_snap_yaml("uses", uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_uses(self):
+        '''Test check_apps_uses()'''
+        uses = self._create_top_uses()
+        apps_uses = self._create_apps_uses()
+        self.set_test_snap_yaml("uses", uses)
+        self.set_test_snap_yaml("apps", apps_uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_uses()
+        r = c.click_report
+        expected_counts = {'info': 10, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_no_uses(self):
+        '''Test check_apps_uses() - no uses'''
+        uses = self._create_top_uses()
+        apps_uses = {'bar': {'command': 'bin/bar'}}
+        self.set_test_snap_yaml("uses", uses)
+        self.set_test_snap_yaml("apps", apps_uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_uses()
+        r = c.click_report
+        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_uses_bad(self):
+        '''Test check_apps_uses() - bad (dict)'''
+        uses = self._create_top_uses()
+        apps_uses = {'bar': {'uses': {}}}
+        self.set_test_snap_yaml("uses", uses)
+        self.set_test_snap_yaml("apps", apps_uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_uses_empty(self):
+        '''Test check_apps_uses() - empty'''
+        uses = self._create_top_uses()
+        apps_uses = {'bar': {'uses': []}}
+        self.set_test_snap_yaml("uses", uses)
+        self.set_test_snap_yaml("apps", apps_uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_uses_bad_entry(self):
+        '''Test check_apps_uses() - bad entry (dict)'''
+        uses = self._create_top_uses()
+        apps_uses = {'bar': {'uses': [{}]}}
+        self.set_test_snap_yaml("uses", uses)
+        self.set_test_snap_yaml("apps", apps_uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_apps_uses_unknown_entry(self):
+        '''Test check_apps_uses() - unknown'''
+        uses = self._create_top_uses()
+        apps_uses = {'bar': {'uses': ['nonexistent']}}
+        self.set_test_snap_yaml("uses", uses)
+        self.set_test_snap_yaml("apps", apps_uses)
+        c = SnapReviewLint(self.test_name)
+        c.check_apps_uses()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+
+class TestSnapReviewLintNoMock(TestCase):
+    """Tests without mocks where they are not needed."""
+    def setUp(self):
+        # XXX cleanup_unpack() is required because global variables
+        # UNPACK_DIR, RAW_UNPACK_DIR are initialised to None at module
+        # load time, but updated when a real (non-Mock) test runs, such as
+        # here. While, at the same time, two of the existing tests using
+        # mocks depend on both global vars being None. Ideally, those
+        # global vars should be refactored away.
+        self.addCleanup(cleanup_unpack)
+        super().setUp()
+
+    def mkdtemp(self):
+        """Create a temp dir which is cleaned up after test."""
+        tmp_dir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, tmp_dir)
+        return tmp_dir
+
+    def check_results(self, report,
+                      expected_counts={'info': 1, 'warn': 0, 'error': 0},
+                      expected=None):
+        common_check_results(self, report, expected_counts, expected)
+
+    def test_check_external_symlinks(self):
+        '''Test check_external_symlinks()'''
+        package = utils.make_snap2(output_dir=self.mkdtemp())
+        c = SnapReviewLint(package)
+        c.check_external_symlinks()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_external_symlinks_has_symlink(self):
+        '''Test check_external_symlinks() - has symlink'''
+        package = utils.make_snap2(output_dir=self.mkdtemp(),
+                                   extra_files=['/some/where,outside']
+                                   )
+        c = SnapReviewLint(package)
+        c.check_external_symlinks()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_architecture_all(self):
+        '''Test check_architecture_all()'''
+        package = utils.make_snap2(output_dir=self.mkdtemp())
+        c = SnapReviewLint(package)
+        c.check_architecture_all()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architecture_all_has_binary(self):
+        '''Test check_architecture_all() - has binary'''
+        package = utils.make_snap2(output_dir=self.mkdtemp(),
+                                   extra_files=['/bin/ls:ls']
+                                   )
+        c = SnapReviewLint(package)
+        c.check_architecture_all()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 0, 'error': 1}
+        self.check_results(r, expected_counts)
+
+    def test_check_architecture_specified_needed_has_binary(self):
+        '''Test check_architecture_specified_needed() - has binary'''
+        output_dir = self.mkdtemp()
+        path = os.path.join(output_dir, 'snap.yaml')
+        content = '''
+name: test
+version: 0.1
+summary: some thing
+description: some desc
+architectures: [ amd64 ]
+'''
+        with open(path, 'w') as f:
+            f.write(content)
+
+        package = utils.make_snap2(output_dir=output_dir,
+                                   extra_files=['%s:meta/snap.yaml' % path,
+                                                '/bin/ls:ls'
+                                                ]
+                                   )
+        c = SnapReviewLint(package)
+        c.check_architecture_specified_needed()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_architecture_specified_needed(self):
+        '''Test check_architecture_specified_needed()'''
+        output_dir = self.mkdtemp()
+        path = os.path.join(output_dir, 'snap.yaml')
+        content = '''
+name: test
+version: 0.1
+summary: some thing
+description: some desc
+architectures: [ amd64 ]
+'''
+        with open(path, 'w') as f:
+            f.write(content)
+
+        package = utils.make_snap2(output_dir=output_dir,
+                                   extra_files=['%s:meta/snap.yaml' % path]
+                                   )
+        c = SnapReviewLint(package)
+        c.check_architecture_specified_needed()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 1, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_vcs(self):
+        '''Test check_vcs()'''
+        package = utils.make_snap2(output_dir=self.mkdtemp())
+        c = SnapReviewLint(package)
+        c.check_vcs()
+        r = c.click_report
+        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
+        self.check_results(r, expected_counts)
+
+    def test_check_vcs_bzrignore(self):
+        '''Test check_vcs() - .bzrignore'''
+        package = utils.make_snap2(output_dir=self.mkdtemp(),
+                                   extra_files=['.bzrignore']
+                                   )
+        c = SnapReviewLint(package)
+        c.check_vcs()
+        r = c.click_report
+        expected_counts = {'info': None, 'warn': 1, 'error': 0}
+        self.check_results(r, expected_counts)

=== modified file 'clickreviews/tests/utils.py'
--- clickreviews/tests/utils.py	2016-02-09 21:45:25 +0000
+++ clickreviews/tests/utils.py	2016-02-11 18:32:45 +0000
@@ -1,6 +1,6 @@
 '''utils.py: test utils for click reviewer tools'''
 #
-# Copyright (C) 2013-2015 Canonical Ltd.
+# Copyright (C) 2013-2016 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -14,7 +14,9 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import glob
+from clickreviews.common import (
+    MKSQUASHFS_OPTS
+)
 import json
 import os
 import shutil
@@ -22,17 +24,44 @@
 import tempfile
 
 
-def make_package(name='test', pkgfmt_type='click', pkgfmt_version='0.4',
-                 package_types=None, version='1.0', title="An application",
-                 framework='ubuntu-sdk-15.04', extra_files=None,
-                 output_dir=None):
+def make_snap2(name='test', pkgfmt_type='snap', pkgfmt_version='16.04',
+               version='1.0', summary="An application", extra_files=None,
+               output_dir=None):
+    '''Return the path to a snap v2 package with the given data.
+
+    Caller is responsible for deleting the output_dir afterwards.
+    '''
+    assert(pkgfmt_type == "snap" and pkgfmt_version != "15.04")
+
+    build_dir = tempfile.mkdtemp()
+
+    try:
+        make_dir_structure(build_dir, pkgfmt_type=pkgfmt_type,
+                           pkgfmt_version=pkgfmt_version,
+                           extra_files=extra_files)
+        write_icon(build_dir)
+        description = summary
+        write_meta_data2(build_dir, name, version, summary, description)
+        pkg_path = build_package(build_dir, name, version, pkgfmt_type,
+                                 pkgfmt_version, output_dir=output_dir)
+    finally:
+        shutil.rmtree(build_dir)
+
+    return pkg_path
+
+
+def make_click(name='test', pkgfmt_type='click', pkgfmt_version='0.4',
+               package_types=None, version='1.0', title="An application",
+               framework='ubuntu-sdk-15.04', extra_files=None,
+               output_dir=None):
     """Return the path to a click/snap package with the given data.
 
     Caller is responsible for deleting the output_dir afterwards.
     """
-    is_snap1 = (pkgfmt_type == "snap" and pkgfmt_version == "15.04")
-    # TODO: implement writing snap2 packages
-    # is_snap2 = (pkgfmt_type == "snap" and not pkgfmt_version == "15.04")
+    assert(pkgfmt_type == "click" or (pkgfmt_type == "snap" and
+                                      pkgfmt_version == "15.04"))
+
+    is_snap1 = (pkgfmt_type == "snap")
     build_dir = tempfile.mkdtemp()
     package_types = package_types or []
 
@@ -42,19 +71,19 @@
                            extra_files=extra_files)
         write_icon(build_dir)
 
-        if pkgfmt_type == 'click' or pkgfmt_version == 15.04:
-            write_manifest(build_dir, name, version,
-                           title, framework, package_types,
-                           is_snap1)
-            write_control(build_dir, name, version, title, pkgfmt_version)
-            write_preinst(build_dir)
-            write_apparmor_profile(build_dir, name)
-            write_other_files(build_dir)
-        else:
+        write_manifest(build_dir, name, version,
+                       title, framework, package_types,
+                       is_snap1)
+        write_control(build_dir, name, version, title, pkgfmt_version)
+        write_preinst(build_dir)
+        write_apparmor_profile(build_dir, name)
+        write_other_files(build_dir)
+
+        if pkgfmt_type == 'snap':
             write_meta_data(build_dir, name, version, title, framework)
 
         pkg_path = build_package(build_dir, name, version, pkgfmt_type,
-                                 output_dir=output_dir)
+                                 pkgfmt_version, output_dir=output_dir)
     finally:
         shutil.rmtree(build_dir)
 
@@ -62,33 +91,81 @@
 
 
 def make_dir_structure(path, pkgfmt_type, pkgfmt_version, extra_files=None):
+    '''Create the mandatory dir structure and extra_files. Format for
+       extra_files:
+         path/to/file                   create empty file in path
+         path/to/dir/                   create empty dir in path
+         path/to/source,path/to/link    create symlink in path
+         path/to/source:path/to/link    copy source to path
+
+         For symlink and copy, source can be an absolute path for pointing
+         outside of the dir (for symlinks) or copying into the package.
+    '''
     extra_files = extra_files or []
-    directories = ['meta']
+
+    directories = ['meta']  # write_icon() and write_manifest() assume this
     if pkgfmt_type == 'click' or pkgfmt_version == 15.04:
         directories.append('DEBIAN')
 
-    directories.extend(
-        [os.path.dirname(extra_file) for extra_file in extra_files])
-
+    # enumerate the directories to create
+    for extra_file in extra_files:
+        if ',' in extra_file:
+            extra = extra_file.split(',', 1)[1]
+        elif ':' in extra_file:
+            extra = extra_file.split(':', 1)[1]
+        else:
+            extra = extra_file
+
+        if extra.startswith('/'):
+            extra = extra[1:]
+
+        if extra.endswith('/'):
+            directories.append(extra)
+        else:
+            directories.append(os.path.dirname(extra))
+
+    # make the enumerated directories
     for directory in directories:
         directory = os.path.join(path, directory)
         if not os.path.exists(directory):
             os.makedirs(directory)
 
     for extra_file in extra_files:
-        dirname, basename = os.path.split(extra_file)
+        if extra_file.endswith('/'):  # nothing more to do for directories
+            continue
+
+        source_link = None
+        source_path = None
+        if ',' in extra_file:
+            (source_link, target_path) = extra_file.split(',', 1)
+        elif ':' in extra_file:
+            (source_path, target_path) = extra_file.split(':', 1)
+        else:
+            target_path = extra_file
+
+        dirname, basename = os.path.split(target_path)
         if basename != '':
-            with open(os.path.join(path, extra_file), 'wb'):
-                pass
+            if source_path:
+                if not source_path.startswith('/'):
+                    source_path = os.path.join(path, source_path)
+                shutil.copyfile(source_path, os.path.join(path, target_path))
+            elif source_link:
+                cur = os.getcwd()
+                if target_path.startswith('/'):
+                    target_path = os.path.join(path, target_path[1:])
+                else:
+                    os.chdir(path)
+                os.symlink(source_link, target_path)
+                os.chdir(cur)
+            else:
+                with open(os.path.join(path, target_path), 'wb'):
+                    pass
 
 
 def write_icon(path):
-    # XXX: Update to use a test icon in the branch to guarantee an icon.
-    icons = glob.glob('/usr/share/icons/hicolor/256x256/apps/*.png')
-    if len(icons) > 0:
-        source_path = icons[0]
-        target_path = os.path.join(path, 'meta', 'icon.png')
-        shutil.copyfile(source_path, target_path)
+    source_path = os.path.join(os.getcwd(), 'clickreviews/data/icon.png')
+    target_path = os.path.join(path, 'meta', 'icon.png')
+    shutil.copyfile(source_path, target_path)
 
 
 def write_manifest(path, name, version, title, framework, types, is_snap):
@@ -127,17 +204,37 @@
     content = """architectures:
 icon: meta/icon.png
 name: {}
-version: "{}",
-framework: {},
+version: {}
+framework: {}
 vendor: 'Someone <[e-mail]>',
 """.format(name, version, framework)
 
-    with open(yaml_path, 'w') as f:
-        f.write(content)
+    # don't overwrite 'copy' via make_dir_structure()
+    if not os.path.exists(yaml_path):
+        with open(yaml_path, 'w') as f:
+            f.write(content)
     with open(os.path.join(path, 'meta', 'readme.md'), 'w') as f:
         f.write(title)
 
 
+def write_meta_data2(path, name, version, summary, description, yaml=None):
+    yaml_path = os.path.join(path, 'meta', 'snap.yaml')
+    if yaml:
+        content = yaml
+    else:
+        content = """architectures: [ all ]
+name: {}
+version: {}
+summary: {}
+description: {}
+""".format(name, version, summary, description)
+
+    # don't overwrite 'copy' via make_dir_structure()
+    if not os.path.exists(yaml_path):
+        with open(yaml_path, 'w') as f:
+            f.write(content)
+
+
 def write_control(path, name, version, title, pkgfmt_version):
     control_path = os.path.join(path, 'DEBIAN', 'control')
     control_content = {'Package': name,
@@ -182,15 +279,23 @@
     write_empty_file(os.path.join(path, 'DEBIAN', 'md5sums'))
 
 
-def build_package(path, name, version, format, output_dir=None):
-    filename = "{}_{}_all.{}".format(name, version, format)
+def build_package(path, name, version, pkgfmt_type, pkgfmt_version,
+                  output_dir=None):
+    filename = "{}_{}_all.{}".format(name, version, pkgfmt_type)
     output_dir = output_dir or tempfile.mkdtemp()
     output_path = os.path.join(output_dir, filename)
 
-    # Note: We're not using 'click build' here as it corrects errors (such
-    # as filtering out a .click directory present in the build). We want
-    # to test with manually constructed, potentially tampered-with
-    # clicks/snaps. Ideally, we'd be using click rather than dpkg to
-    # construct the click without filtering any files in the build dir.
-    subprocess.check_call(['dpkg-deb', '-b', path, output_path])
+    if pkgfmt_type == "snap" and pkgfmt_version != "15.04":
+        args = ['mksquashfs', path, output_path] + MKSQUASHFS_OPTS
+        # debugging
+        # subprocess.check_call(args)
+        # subprocess.check_call(['unsquashfs', '-lls', output_path])
+        subprocess.check_call(args, stdout=open(os.devnull, 'w'))
+    else:  # click and snap v1
+        # Note: We're not using 'click build' here as it corrects errors (such
+        # as filtering out a .click directory present in the build). We want
+        # to test with manually constructed, potentially tampered-with
+        # clicks/snaps. Ideally, we'd be using click rather than dpkg to
+        # construct the click without filtering any files in the build dir.
+        subprocess.check_call(['dpkg-deb', '-b', path, output_path])
     return output_path