Merge lp:~jdstrand/click-reviewers-tools/refactor into lp:click-reviewers-tools

[Jamie Strandboge]

This is just the refactor MP. The snap.yaml MP will be based on this.

- rename bin/unpack-click as bin/unpack-package
- add common.py
  + refactor non-click and non-snap1 bits from cr_common.py
  + add proper package detection API and variables for click, snap1 and snap2
- clickreviews/cr_* (and tests)
  + adjust for common.py
  + use new detection variables and only run on click and snap1 snaps
  + cleanup cr_common.py to remove snap2 support (will be added in a later
    commit)
- clickreviews/cr_tests.py:
  + remove snap2 support (will be added in a later commit)
  + add detect_package support
  + various cleanups for refactoring
- adjust bin/*, clickreviews/* and clickreviews/tests/* to use common instead
  of cr_common
- bin/click-run-checks, clickreviews/modules.py: don't assume 'click' in
  variable names, etc
- pull existing snap v2 tests out of cr_*
- add bin/detect-package

# click
PYTHONPATH=./ ./bin/click-review -v ../rottentomatoes/rottentomatoes.jdstrand_0.11.2_all.click | grep 'OK' |wc -l
120

(previous showed 121-- this is because 'framework:obsolete_declaration' is not needed on click but was previously being tested)

# snap v1
$ PYTHONPATH=./ ./bin/click-review -v ../ufw-trunk/ufw_0.35_all.snap | grep OK|wc -l
264

(previous shows 264)

# snap v2 (no checks run)
$ PYTHONPATH=./ ./bin/click-review -v ../snappy-debug/snappy-debug_0.12_all.snap | grep OK|wc -l
0

I also checked click-review -v output against current trunk and this branch and all the tests are still run (excepting 'framework:obsolete_declaration' on click, see above).

[Daniel Holbach (dholbach)]

Great work!

review: Approve

[lp:~jdstrand/click-reviewers-tools/refactor]

580. By Jamie Strandboge on 2016-02-10

clickreviews/cr_security.py: clarify logic of package detection in two tests

581. By Jamie Strandboge on 2016-02-10

clickreviews/cr_lint.py: don't run check_contents_for_hardcoded_paths() on
snap v2

[James Tait (jamestait)]

Fantastic job! So much clearer!

review: Approve

=== modified file 'README'
--- README	2015-06-10 21:56:24 +0000
+++ README	2016-02-10 19:30:47 +0000
@@ -1,4 +1,4 @@
-Runnable tests:
+Runnable click and snap v1 tests:
 - bin/click-check-bin-path: snappy bin-path tests
 - bin/click-check-content-hub: content-hub hook tests
 - bin/click-check-desktop: desktop hook tests

=== modified file 'bin/click-check-bin-path'
--- bin/click-check-bin-path	2015-03-18 19:57:47 +0000
+++ bin/click-check-bin-path	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_bin_path as cr_bin_path
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_bin_path.ClickReviewBinPath)
+    common.run_check(cr_bin_path.ClickReviewBinPath)

=== modified file 'bin/click-check-content-hub'
--- bin/click-check-content-hub	2015-03-18 19:57:47 +0000
+++ bin/click-check-content-hub	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_content_hub as cr_content_hub
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_content_hub.ClickReviewContentHub)
+    common.run_check(cr_content_hub.ClickReviewContentHub)

=== modified file 'bin/click-check-desktop'
--- bin/click-check-desktop	2015-03-18 19:57:47 +0000
+++ bin/click-check-desktop	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-from clickreviews import cr_common
+from clickreviews import common
 from clickreviews import cr_desktop
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_desktop.ClickReviewDesktop)
+    common.run_check(cr_desktop.ClickReviewDesktop)

=== modified file 'bin/click-check-framework'
--- bin/click-check-framework	2015-03-18 19:57:47 +0000
+++ bin/click-check-framework	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_framework as cr_framework
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_framework.ClickReviewFramework)
+    common.run_check(cr_framework.ClickReviewFramework)

=== modified file 'bin/click-check-functional'
--- bin/click-check-functional	2015-03-18 19:57:47 +0000
+++ bin/click-check-functional	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_functional as cr_functional
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_functional.ClickReviewFunctional)
+    common.run_check(cr_functional.ClickReviewFunctional)

=== modified file 'bin/click-check-lint'
--- bin/click-check-lint	2015-03-18 19:57:47 +0000
+++ bin/click-check-lint	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_lint as cr_lint
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_lint.ClickReviewLint)
+    common.run_check(cr_lint.ClickReviewLint)

=== modified file 'bin/click-check-online-accounts'
--- bin/click-check-online-accounts	2015-03-18 19:57:47 +0000
+++ bin/click-check-online-accounts	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_online_accounts as cr_online_accounts
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_online_accounts.ClickReviewAccounts)
+    common.run_check(cr_online_accounts.ClickReviewAccounts)

=== modified file 'bin/click-check-push-helper'
--- bin/click-check-push-helper	2015-03-18 19:57:47 +0000
+++ bin/click-check-push-helper	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_push_helper as cr_push_helper
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_push_helper.ClickReviewPushHelper)
+    common.run_check(cr_push_helper.ClickReviewPushHelper)

=== modified file 'bin/click-check-scope'
--- bin/click-check-scope	2015-03-18 19:57:47 +0000
+++ bin/click-check-scope	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_scope as cr_scope
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_scope.ClickReviewScope)
+    common.run_check(cr_scope.ClickReviewScope)

=== modified file 'bin/click-check-security'
--- bin/click-check-security	2015-03-18 19:57:47 +0000
+++ bin/click-check-security	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_security as cr_security
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_security.ClickReviewSecurity)
+    common.run_check(cr_security.ClickReviewSecurity)

=== modified file 'bin/click-check-skeleton'
--- bin/click-check-skeleton	2015-03-18 19:57:47 +0000
+++ bin/click-check-skeleton	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_skeleton as cr_skeleton
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_skeleton.ClickReviewSkeleton)
+    common.run_check(cr_skeleton.ClickReviewSkeleton)

=== modified file 'bin/click-check-systemd'
--- bin/click-check-systemd	2015-03-18 20:01:56 +0000
+++ bin/click-check-systemd	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_systemd as cr_systemd
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_systemd.ClickReviewSystemd)
+    common.run_check(cr_systemd.ClickReviewSystemd)

=== modified file 'bin/click-check-url-dispatcher'
--- bin/click-check-url-dispatcher	2015-03-18 19:57:47 +0000
+++ bin/click-check-url-dispatcher	2016-02-10 19:30:47 +0000
@@ -17,8 +17,8 @@
 
 from __future__ import print_function
 
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 import clickreviews.cr_url_dispatcher as cr_url_dispatcher
 
 if __name__ == "__main__":
-    cr_common.run_click_check(cr_url_dispatcher.ClickReviewUrlDispatcher)
+    common.run_check(cr_url_dispatcher.ClickReviewUrlDispatcher)

=== modified file 'bin/click-review'
--- bin/click-review	2014-11-22 04:33:00 +0000
+++ bin/click-review	2016-02-10 19:30:47 +0000
@@ -33,7 +33,7 @@
     def __init__(self, args):
         self.args = args
         self.click_fn = self.args.filename
-        self.cr_modules = modules.get_modules()
+        self.modules = modules.get_modules()
 
     def _sumarise_results(self):
         for module in self.results:
@@ -96,12 +96,12 @@
 
     def run_all_checks(self):
         if self.args.sdk:
-            for module in self.cr_modules:
+            for module in self.modules:
                 section = self._run_module_checks(module)
                 if section:
                     self._report_module(section)
         else:
-            for module in self.cr_modules:
+            for module in self.modules:
                 self._run_module_checks(module)
             self._complete_report()
 
@@ -125,7 +125,7 @@
         sys.exit(1)
 
     results = Results(args)
-    if not results.cr_modules:
+    if not results.modules:
         print("No 'clickreviews' modules found.")
         sys.exit(1)
 

=== modified file 'bin/click-run-checks'
--- bin/click-run-checks	2015-03-18 20:49:03 +0000
+++ bin/click-run-checks	2016-02-10 19:30:47 +0000
@@ -11,10 +11,10 @@
 fi
 
 # prefer local script for testing, otherwise use system location
-CLICK_CHECKS_BIN_PATH="$(dirname $(readlink -f "$0"))"
+CHECKS_BIN_PATH="$(dirname $(readlink -f "$0"))"
 
 prefer_local() {
-    path="${CLICK_CHECKS_BIN_PATH}/$1"
+    path="${CHECKS_BIN_PATH}/$1"
     if [ -x $path ]; then
         "$path" "$2" || set_rc "$?"
         return
@@ -37,10 +37,10 @@
 
 prefer_local click-show-files "$c"
 
-CLICK_CHECKS=$(ls ${CLICK_CHECKS_BIN_PATH}/click-check-* | grep -v click-check-skeleton | grep -v click-check-lint)
-CLICK_CHECKS="click-check-lint ${CLICK_CHECKS}"
-for check_path in ${CLICK_CHECKS}; do
-    check=$(basename ${check_path} ${CLICK_CHECKS_BIN_PATH})
+CHECKS=$(ls ${CHECKS_BIN_PATH}/click-check-* | egrep -v '(click-check-skeleton|click-check-lint)')
+CHECKS="click-check-lint ${CHECKS}"
+for check_path in ${CHECKS}; do
+    check=$(basename ${check_path} ${CHECKS_BIN_PATH})
     echo ""
     echo "=" $check "="
     prefer_local $check "$c"

=== modified file 'bin/click-show-files'
--- bin/click-show-files	2015-04-01 23:31:56 +0000
+++ bin/click-show-files	2016-02-10 19:30:47 +0000
@@ -19,7 +19,7 @@
 import os
 import sys
 
-from clickreviews import cr_common
+from clickreviews import common
 from clickreviews import cr_desktop
 from clickreviews import cr_lint
 from clickreviews import cr_security
@@ -36,12 +36,12 @@
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:
-        cr_common.error("Must give path to click package")
+        common.error("Must give path to package")
 
     review = cr_lint.ClickReviewLint(sys.argv[1])
 
     for i in sorted(review.control_files):
-        fh = cr_common.open_file_read(review.control_files[i])
+        fh = common.open_file_read(review.control_files[i])
         print("= %s =" % os.path.basename(i))
         for line in fh.readlines():
             print(line, end="")
@@ -51,7 +51,7 @@
     fn = os.path.join(review.unpack_dir, "meta", "package.yaml")
     if os.path.exists(fn):
         print("= %s =" % os.path.basename(fn))
-        fh = cr_common.open_file_read(fn)
+        fh = common.open_file_read(fn)
         for line in fh.readlines():
             print(line, end="")
         fh.close()
@@ -62,7 +62,7 @@
     review_content_hub = cr_content_hub.ClickReviewContentHub(sys.argv[1])
     for app in sorted(review_content_hub.content_hub_files):
         f = review_content_hub.content_hub_files[app]
-        fh = cr_common.open_file_read(os.path.join(
+        fh = common.open_file_read(os.path.join(
             review_content_hub.unpack_dir, f))
         print("== content_hub: %s ==" % os.path.basename(f))
         for line in fh.readlines():
@@ -73,8 +73,7 @@
     review_desktop = cr_desktop.ClickReviewDesktop(sys.argv[1])
     for app in sorted(review_desktop.desktop_files):
         f = review_desktop.desktop_files[app]
-        fh = cr_common.open_file_read(os.path.join(review_desktop.unpack_dir,
-                                                   f))
+        fh = common.open_file_read(os.path.join(review_desktop.unpack_dir, f))
         print("== desktop: %s ==" % os.path.basename(f))
         for line in fh.readlines():
             print(line, end="")
@@ -87,7 +86,7 @@
             if account_type not in review_accounts.accounts_files[app]:
                 continue
             f = review_accounts.accounts_files[app][account_type]
-            fh = cr_common.open_file_read(os.path.join(
+            fh = common.open_file_read(os.path.join(
                 review_accounts.unpack_dir, f))
             print("== online %s: %s ==" % (account_type, os.path.basename(f)))
             for line in fh.readlines():
@@ -98,7 +97,7 @@
     review_push_helper = cr_push_helper.ClickReviewPushHelper(sys.argv[1])
     for app in sorted(review_push_helper.push_helper_files):
         f = review_push_helper.push_helper_files[app]
-        fh = cr_common.open_file_read(os.path.join(
+        fh = common.open_file_read(os.path.join(
             review_push_helper.unpack_dir, f))
         print("== push_helper: %s ==" % os.path.basename(f))
         for line in fh.readlines():
@@ -109,7 +108,7 @@
     review_scope = cr_scope.ClickReviewScope(sys.argv[1])
     for app in sorted(review_scope.scopes):
         f = review_scope.scopes[app]["ini_file"]
-        fh = cr_common.open_file_read(os.path.join(review_scope.unpack_dir, f))
+        fh = common.open_file_read(os.path.join(review_scope.unpack_dir, f))
         print("== scope .INI: %s ==" % os.path.basename(f))
         for line in fh.readlines():
             print(line, end="")
@@ -120,7 +119,7 @@
     for app in sorted(review_framework.frameworks_file):
         f = os.path.join(review_framework.unpack_dir,
                          review_framework.frameworks_file[app])
-        fh = cr_common.open_file_read(os.path.join(review_framework.unpack_dir, f))
+        fh = common.open_file_read(os.path.join(review_framework.unpack_dir, f))
         print("== click .framework: %s ==" % os.path.basename(f))
         for line in fh.readlines():
             print(line, end="")
@@ -135,8 +134,7 @@
 
     review_apparmor = cr_security.ClickReviewSecurity(sys.argv[1])
     for f in sorted(review_apparmor.security_manifests):
-        fh = cr_common.open_file_read(os.path.join(review_apparmor.unpack_dir,
-                                                   f))
+        fh = common.open_file_read(os.path.join(review_apparmor.unpack_dir, f))
         print("== security: %s ==" % os.path.basename(f))
         for line in fh.readlines():
             print(line, end="")
@@ -146,8 +144,7 @@
     review_systemd = cr_systemd.ClickReviewSystemd(sys.argv[1])
     for app in sorted(review_systemd.systemd_files):
         f = review_systemd.systemd_files[app]
-        fh = cr_common.open_file_read(os.path.join(review_systemd.unpack_dir,
-                                                   f))
+        fh = common.open_file_read(os.path.join(review_systemd.unpack_dir, f))
         print("== systemd: %s ==" % os.path.basename(f))
         for line in fh.readlines():
             print(line, end="")
@@ -157,8 +154,8 @@
     review_url_dispatcher = cr_url_dispatcher.ClickReviewUrlDispatcher(sys.argv[1])
     for app in sorted(review_url_dispatcher.url_dispatcher_files):
         f = review_url_dispatcher.url_dispatcher_files[app]
-        fh = cr_common.open_file_read(os.path.join(review_url_dispatcher.unpack_dir,
-                                                   f))
+        fh = common.open_file_read(os.path.join(review_url_dispatcher.unpack_dir,
+                                                f))
         print("== url_dispatcher: %s ==" % os.path.basename(f))
         for line in fh.readlines():
             print(line, end="")
@@ -166,4 +163,4 @@
         print("")
 
     # Cleanup our unpack directory
-    cr_common.cleanup_unpack()
+    common.cleanup_unpack()

=== added file 'bin/detect-package'
--- bin/detect-package	1970-01-01 00:00:00 +0000
+++ bin/detect-package	2016-02-10 19:30:47 +0000
@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+
+import os
+import sys
+
+from clickreviews import common
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        common.error("%s <pkg>" % os.path.basename(sys.argv[0]))
+
+    pkg = sys.argv[1]
+
+    (t, v) = common.detect_package(pkg)
+    print ("%s\t%d" % (t, v))

=== modified file 'bin/download-click'
--- bin/download-click	2013-10-02 14:02:34 +0000
+++ bin/download-click	2016-02-10 19:30:47 +0000
@@ -23,7 +23,7 @@
 import sys
 import time
 
-from clickreviews import cr_common
+from clickreviews import common
 
 top_url = "https://search.apps.ubuntu.com"
 
@@ -40,12 +40,12 @@
 def download(entry, download_dir=None):
     '''Download a click app'''
     if 'resource_url' not in entry:
-        cr_common.error("Could not find 'resource_url' in:\n%s" % entry)
+        common.error("Could not find 'resource_url' in:\n%s" % entry)
     resource_url = top_url + entry['resource_url']
 
     res = get_store_json(resource_url)
     if 'download_url' not in res:
-        cr_common.error("Could not find 'download_url' in:\n%s" % res)
+        common.error("Could not find 'download_url' in:\n%s" % res)
     download_url = res['download_url']
 
     if download_dir is None:
@@ -55,12 +55,12 @@
 
     fn = os.path.join(download_dir, download_url.split('/')[-1])
     if os.path.exists(fn):
-        cr_common.warn("'%s' already exists, skipping" % os.path.basename(fn))
+        common.warn("'%s' already exists, skipping" % os.path.basename(fn))
         return True
-    cr_common.msg("Downloading %s" % os.path.basename(fn))
+    common.msg("Downloading %s" % os.path.basename(fn))
     # FIXME: on 2013-10-15 this will break
     url = download_url + "?noauth=1"
-    cr_common.msg("-- Downloading %s" % url)
+    common.msg("-- Downloading %s" % url)
 
     #  attempt to deal with intermittent failures
     count = 0
@@ -72,14 +72,14 @@
             (tmp, headers) = urllib.request.urlretrieve(url)
             shutil.move(tmp, fn)
             result = True
-            cr_common.msg("-- Success!")
+            common.msg("-- Success!")
         except urllib.error.HTTPError as error:
             err_str = "-- urlretrieve() failed: %d: %s" % (error.code,
                                                            error.reason)
             count += 1
             time.sleep(5)
     if not result:
-        cr_common.warn("%s (tried %d times)" % (err_str, max_tries))
+        common.warn("%s (tried %d times)" % (err_str, max_tries))
     return result
 
 if __name__ == "__main__":
@@ -96,12 +96,12 @@
     (opt, args) = parser.parse_args()
 
     if not opt.all and len(args) < 1:
-        cr_common.error("%s --all|<pkgname>" % os.path.basename(sys.argv[0]))
+        common.error("%s --all|<pkgname>" % os.path.basename(sys.argv[0]))
 
     url = top_url + "/api/v1/search?q="
     items = get_store_json(url)
     if not isinstance(items, list):
-        cr_common.error("Didn't get valid result from: %s" % url)
+        common.error("Didn't get valid result from: %s" % url)
 
     errors = False
     if opt.all:
@@ -117,10 +117,10 @@
                     break
 
             if not entry:
-                cr_common.warn("Could not find '%s', skipping" % pkgname)
+                common.warn("Could not find '%s', skipping" % pkgname)
                 continue
 
             if not download(entry, opt.download_dir):
                 errors = True
     if errors:
-        cr_common.error("problem downloading")
+        common.error("problem downloading")

=== modified file 'bin/repack-click'
--- bin/repack-click	2014-06-27 18:58:30 +0000
+++ bin/repack-click	2016-02-10 19:30:47 +0000
@@ -6,7 +6,7 @@
 import sys
 import os
 
-from clickreviews import cr_common
+from clickreviews import common
 from debian.deb822 import Deb822
 import glob
 import shutil
@@ -16,45 +16,45 @@
 def repack_click(unpack_dir, click_package):
     '''Repack the click package'''
     if not os.path.isdir(unpack_dir):
-        cr_common.error("'%s' does not exist" % unpack_dir)
+        common.error("'%s' does not exist" % unpack_dir)
     if os.path.exists(click_package):
-        cr_common.error("'%s' exists" % click_package)
+        common.error("'%s' exists" % click_package)
 
     control_fn = os.path.join(unpack_dir, "DEBIAN/control")
     if not os.path.exists(control_fn):
-        cr_common.error("Could not find '%s'" % control_fn)
-    fh = cr_common.open_file_read(control_fn)
+        common.error("Could not find '%s'" % control_fn)
+    fh = common.open_file_read(control_fn)
     tmp = list(Deb822.iter_paragraphs(fh.readlines()))
     fh.close()
     if len(tmp) != 1:
-        cr_common.error("malformed control file: too many paragraphs")
+        common.error("malformed control file: too many paragraphs")
     control = tmp[0]
 
     click_fn = "%s_%s_%s.click" % (control['Package'],
                                    control['Version'],
                                    control['Architecture'])
     if os.path.basename(click_package) != click_fn:
-        cr_common.warn("'%s' should be '%s'" % (click_package, click_fn))
+        common.warn("'%s' should be '%s'" % (click_package, click_fn))
 
     tmpdir = tempfile.mkdtemp(prefix='clickreview-')
     curdir = os.getcwd()
     os.chdir(tmpdir)
-    (rc, out) = cr_common.cmd(['dpkg-deb', '-b', '--nocheck', '-Zgzip',
+    (rc, out) = common.cmd(['dpkg-deb', '-b', '--nocheck', '-Zgzip',
                                os.path.abspath(unpack_dir),
                                os.path.join(tmpdir, click_fn)])
     os.chdir(curdir)
     if rc != 0:
-        cr_common.recursive_rm(tmpdir)
-        cr_common.error("dpkg-deb -b failed with '%d':\n%s" % (rc, out))
+        common.recursive_rm(tmpdir)
+        common.error("dpkg-deb -b failed with '%d':\n%s" % (rc, out))
 
     debfile = glob.glob("%s/*.click" % tmpdir)[0]
     shutil.move(debfile, os.path.abspath(click_package))
-    cr_common.recursive_rm(tmpdir)
+    common.recursive_rm(tmpdir)
 
 
 if __name__ == '__main__':
     if len(sys.argv) != 3:
-        cr_common.error("%s <unpacked dir> <clickpkg>" %
+        common.error("%s <unpacked dir> <clickpkg>" %
                         os.path.basename(sys.argv[0]))
 
     dir = sys.argv[1]

=== renamed file 'bin/unpack-click' => 'bin/unpack-package'
--- bin/unpack-click	2013-09-26 11:47:37 +0000
+++ bin/unpack-package	2016-02-10 19:30:47 +0000
@@ -3,14 +3,14 @@
 import os
 import sys
 
-from clickreviews import cr_common
+from clickreviews import common
 
 if __name__ == '__main__':
     if len(sys.argv) != 3:
-        cr_common.error("%s <clickpkg> <dir>" % os.path.basename(sys.argv[0]))
+        common.error("%s <clickpkg> <dir>" % os.path.basename(sys.argv[0]))
 
     pkg = sys.argv[1]
     dir = sys.argv[2]
 
-    cr_common.unpack_click(pkg, dir)
+    common.unpack_pkg(pkg, dir)
     print("Successfully unpacked to '%s'" % dir)

=== modified file 'check-names.list'
--- check-names.list	2016-02-01 19:12:30 +0000
+++ check-names.list	2016-02-10 19:30:47 +0000
@@ -45,7 +45,6 @@
 framework:policy_unknown|
 framework:policy_valid_name|
 lint:architecture_specified_needed|
-lint:check_squashfs_uses_snap_yaml|
 lint:click_local_extensions|
 lint:control_architecture_match|
 lint:control_architecture_valid|
@@ -71,7 +70,6 @@
 lint:hooks_multiple_apps|
 lint:hooks_redflag|
 lint:hooks_valid|
-lint:is_squashfs|
 lint:maintainer_format|http://askubuntu.com/questions/417351/what-does-lint-maintainer-format-mean/417352
 lint:maintainer_present|
 lint:manifest_architecture_valid|
@@ -159,7 +157,6 @@
 security:yaml_combinations|
 security:yaml_override_click|
 security:yaml_override_format|
-security:yaml_override_present|https://developer.ubuntu.com/en/snappy/guides/security-policy/
 security:yaml_policy_format|
 security:yaml_policy_present|https://developer.ubuntu.com/en/snappy/guides/security-policy/
 security:yaml_security-template|

=== added file 'clickreviews/common.py'
--- clickreviews/common.py	1970-01-01 00:00:00 +0000
+++ clickreviews/common.py	2016-02-10 19:30:47 +0000
@@ -0,0 +1,514 @@
+'''common.py: common classes and functions'''
+#
+# 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 atexit
+import codecs
+import inspect
+import json
+import logging
+import magic
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import types
+
+
+DEBUGGING = False
+UNPACK_DIR = None
+RAW_UNPACK_DIR = None
+
+
+def cleanup_unpack():
+    global UNPACK_DIR
+    if UNPACK_DIR is not None and os.path.isdir(UNPACK_DIR):
+        recursive_rm(UNPACK_DIR)
+        UNPACK_DIR = None
+    global RAW_UNPACK_DIR
+    if RAW_UNPACK_DIR is not None and os.path.isdir(RAW_UNPACK_DIR):
+        recursive_rm(RAW_UNPACK_DIR)
+        RAW_UNPACK_DIR = None
+atexit.register(cleanup_unpack)
+
+
+#
+# Utility classes
+#
+class ReviewException(Exception):
+    '''This class represents Review exceptions'''
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class Review(object):
+    '''Common review class'''
+    magic_binary_file_descriptions = [
+        'application/x-executable; charset=binary',
+        'application/x-sharedlib; charset=binary',
+        'application/x-object; charset=binary',
+        'application/octet-stream; charset=binary'
+    ]
+
+    def __init__(self, fn, review_type, overrides=None):
+        self.pkg_filename = fn
+        self._check_package_exists()
+
+        self.review_type = review_type
+        # TODO: rename as pkg_report
+        self.click_report = dict()
+
+        self.result_types = ['info', 'warn', 'error']
+        for r in self.result_types:
+            self.click_report[r] = dict()
+
+        self.click_report_output = "json"
+
+        global UNPACK_DIR
+        if UNPACK_DIR is None:
+            UNPACK_DIR = unpack_pkg(fn)
+        self.unpack_dir = UNPACK_DIR
+
+        global RAW_UNPACK_DIR
+        if RAW_UNPACK_DIR is None:
+            RAW_UNPACK_DIR = raw_unpack_pkg(fn)
+        self.raw_unpack_dir = RAW_UNPACK_DIR
+
+        self.is_click = False
+        self.is_snap1 = False
+        self.is_snap2 = False
+        self.pkgfmt = {"type": "", "version": ""}
+
+        (self.pkgfmt["type"], pkgver) = detect_package(fn, self.unpack_dir)
+
+        if self._pkgfmt_type() == "snap":
+            if pkgver < 2:
+                self.is_snap1 = True
+                self.pkgfmt["version"] = "15.04"
+            else:
+                self.is_snap2 = True
+                self.pkgfmt["version"] = "16.04"
+        elif self._pkgfmt_type() == "click":
+            self.pkgfmt["version"] = "0.4"
+            self.is_click = True
+        else:
+            error("Unknown package type: '%s'" % self._pkgfmt_type())
+
+        # Get a list of all unpacked files
+        self.pkg_files = []
+        self._list_all_files()
+
+        # Setup what is needed to get a list of all unpacked compiled binaries
+        self.mime = magic.open(magic.MAGIC_MIME)
+        self.mime.load()
+        self.pkg_bin_files = []
+        # Don't run this here since only cr_lint.py and cr_functional.py need
+        # it now
+        # self._list_all_compiled_binaries()
+
+        self.overrides = overrides if overrides is not None else {}
+
+    def _check_innerpath_executable(self, fn):
+        '''Check that the provided path exists and is executable'''
+        return os.access(fn, os.X_OK)
+
+    def _extract_statinfo(self, fn):
+        '''Extract statinfo from file'''
+        try:
+            st = os.stat(fn)
+        except Exception:
+            return None
+        return st
+
+    def _path_join(self, dirname, rest):
+        return os.path.join(dirname, rest)
+
+    def _get_sha512sum(self, fn):
+        '''Get sha512sum of file'''
+        (rc, out) = cmd(['sha512sum', fn])
+        if rc != 0:
+            return None
+        return out.split()[0]
+
+    def _pkgfmt_type(self):
+        '''Return the package format type'''
+        if "type" not in self.pkgfmt:
+            return ""
+        return self.pkgfmt["type"]
+
+    def _pkgfmt_version(self):
+        '''Return the package format version'''
+        if "version" not in self.pkgfmt:
+            return ""
+        return self.pkgfmt["version"]
+
+    def _check_package_exists(self):
+        '''Check that the provided package exists'''
+        if not os.path.exists(self.pkg_filename):
+            error("Could not find '%s'" % self.pkg_filename)
+
+    def _list_all_files(self):
+        '''List all files included in this click package.'''
+        for root, dirnames, filenames in os.walk(self.unpack_dir):
+            for f in filenames:
+                self.pkg_files.append(os.path.join(root, f))
+
+    def _check_if_message_catalog(self, fn):
+        '''Check if file is a message catalog (.mo file).'''
+        if fn.endswith('.mo'):
+            return True
+        return False
+
+    def _list_all_compiled_binaries(self):
+        '''List all compiled binaries in this click package.'''
+        for i in self.pkg_files:
+            res = self.mime.file(i)
+            if res in self.magic_binary_file_descriptions and \
+               not self._check_if_message_catalog(i):
+                self.pkg_bin_files.append(i)
+
+    def _get_check_name(self, name, app='', extra=''):
+        name = ':'.join([self.review_type, name])
+        if app:
+            name += ':' + app
+        if extra:
+            name += ':' + extra
+        return name
+
+    def _verify_pkgversion(self, v):
+        '''Verify package name'''
+        if not isinstance(v, (str, int, float)):
+            return False
+        re_valid_version = re.compile(r'^((\d+):)?'              # epoch
+                                      '([A-Za-z0-9.+:~-]+?)'     # upstream
+                                      '(-([A-Za-z0-9+.~]+))?$')  # debian
+        if re_valid_version.match(str(v)):
+            return True
+        return False
+
+    # click_report[<result_type>][<review_name>] = <result>
+    #   result_type: info, warn, error
+    #   review_name: name of the check (prefixed with self.review_type)
+    #   result: contents of the review
+    def _add_result(self, result_type, review_name, result, link=None,
+                    manual_review=False):
+        '''Add result to report'''
+        if result_type not in self.result_types:
+            error("Invalid result type '%s'" % result_type)
+
+        if review_name not in self.click_report[result_type]:
+            # log info about check so it can be collected into the
+            # check-names.list file
+            # format should be
+            # CHECK|<review_type:check_name>|<link>
+            msg = 'CHECK|{}|{}'
+            name = ':'.join(review_name.split(':')[:2])
+            link_text = link if link is not None else ""
+            logging.debug(msg.format(name, link_text))
+            self.click_report[result_type][review_name] = dict()
+
+        self.click_report[result_type][review_name].update({
+            'text': result,
+            'manual_review': manual_review,
+        })
+        if link is not None:
+            self.click_report[result_type][review_name]["link"] = link
+
+    def do_report(self):
+        '''Print report'''
+        if self.click_report_output == "console":
+            # TODO: format better
+            import pprint
+            pprint.pprint(self.click_report)
+        elif self.click_report_output == "json":
+            import json
+            msg(json.dumps(self.click_report,
+                           sort_keys=True,
+                           indent=2,
+                           separators=(',', ': ')))
+
+        rc = 0
+        if len(self.click_report['error']):
+            rc = 2
+        elif len(self.click_report['warn']):
+            rc = 1
+        return rc
+
+    def do_checks(self):
+        '''Run all methods that start with check_'''
+        methodList = [name for name, member in
+                      inspect.getmembers(self, inspect.ismethod)
+                      if isinstance(member, types.MethodType)]
+        for methodname in methodList:
+            if not methodname.startswith("check_"):
+                continue
+            func = getattr(self, methodname)
+            func()
+
+    def set_review_type(self, name):
+        '''Set review name'''
+        self.review_type = name
+
+
+#
+# Utility functions
+#
+
+def error(out, exit_code=1, do_exit=True):
+    '''Print error message and exit'''
+    try:
+        print("ERROR: %s" % (out), file=sys.stderr)
+    except IOError:
+        pass
+
+    if do_exit:
+        sys.exit(exit_code)
+
+
+def warn(out):
+    '''Print warning message'''
+    try:
+        print("WARN: %s" % (out), file=sys.stderr)
+    except IOError:
+        pass
+
+
+def msg(out, output=sys.stdout):
+    '''Print message'''
+    try:
+        print("%s" % (out), file=output)
+    except IOError:
+        pass
+
+
+def debug(out):
+    '''Print debug message'''
+    global DEBUGGING
+    if DEBUGGING:
+        try:
+            print("DEBUG: %s" % (out), file=sys.stderr)
+        except IOError:
+            pass
+
+
+def cmd(command):
+    '''Try to execute the given command.'''
+    debug(command)
+    try:
+        sp = subprocess.Popen(command, stdout=subprocess.PIPE,
+                              stderr=subprocess.STDOUT)
+    except OSError as ex:
+        return [127, str(ex)]
+
+    if sys.version_info[0] >= 3:
+        out = sp.communicate()[0].decode('ascii', 'ignore')
+    else:
+        out = sp.communicate()[0]
+
+    return [sp.returncode, out]
+
+
+def cmd_pipe(command1, command2):
+    '''Try to pipe command1 into command2.'''
+    try:
+        sp1 = subprocess.Popen(command1, stdout=subprocess.PIPE)
+        sp2 = subprocess.Popen(command2, stdin=sp1.stdout)
+    except OSError as ex:
+        return [127, str(ex)]
+
+    if sys.version_info[0] >= 3:
+        out = sp2.communicate()[0].decode('ascii', 'ignore')
+    else:
+        out = sp2.communicate()[0]
+
+    return [sp2.returncode, out]
+
+
+def _unpack_cmd(cmd_args, d, dest):
+    '''Low level unpack helper'''
+    curdir = os.getcwd()
+    os.chdir(d)
+
+    (rc, out) = cmd(cmd_args)
+    os.chdir(curdir)
+
+    if rc != 0:
+        if os.path.isdir(d):
+            recursive_rm(d)
+        error("unpacking failed with '%d':\n%s" % (rc, out))
+
+    if dest is None:
+        dest = d
+    else:
+        shutil.move(d, dest)
+
+    return dest
+
+
+def _unpack_snap_squashfs(snap_pkg, dest):
+    '''Unpack a squashfs based snap package to dest'''
+    d = tempfile.mkdtemp(prefix='clickreview-')
+    return _unpack_cmd(['unsquashfs', '-f', '-d', d,
+                        os.path.abspath(snap_pkg)], d, dest)
+
+
+def _unpack_click_deb(pkg, dest):
+    d = tempfile.mkdtemp(prefix='clickreview-')
+    return _unpack_cmd(['dpkg-deb', '-R',
+                        os.path.abspath(pkg), d], d, dest)
+
+
+def unpack_pkg(fn, dest=None):
+    '''Unpack package'''
+    if not os.path.isfile(fn):
+        error("Could not find '%s'" % fn)
+    pkg = fn
+    if not pkg.startswith('/'):
+        pkg = os.path.abspath(pkg)
+
+    if dest is not None and os.path.exists(dest):
+        error("'%s' exists. Aborting." % dest)
+
+    # check if its a squashfs based snap
+    if is_squashfs(pkg):
+        return _unpack_snap_squashfs(fn, dest)
+
+    return _unpack_click_deb(fn, dest)
+
+
+def is_squashfs(filename):
+    '''Return true if the given filename as a squashfs header'''
+    with open(filename, 'rb') as f:
+        header = f.read(10)
+    return header.startswith(b"hsqs")
+
+
+def raw_unpack_pkg(fn, dest=None):
+    '''Unpack raw package'''
+    if not os.path.isfile(fn):
+        error("Could not find '%s'" % fn)
+    pkg = fn
+    if not pkg.startswith('/'):
+        pkg = os.path.abspath(pkg)
+    # nothing to do for squashfs images
+    if is_squashfs(pkg):
+        return ""
+
+    if dest is not None and os.path.exists(dest):
+        error("'%s' exists. Aborting." % dest)
+
+    d = tempfile.mkdtemp(prefix='review-')
+
+    curdir = os.getcwd()
+    os.chdir(d)
+    (rc, out) = cmd(['ar', 'x', pkg])
+    os.chdir(curdir)
+
+    if rc != 0:
+        if os.path.isdir(d):
+            recursive_rm(d)
+        error("'ar x' failed with '%d':\n%s" % (rc, out))
+
+    if dest is None:
+        dest = d
+    else:
+        shutil.move(d, dest)
+
+    return dest
+
+
+def open_file_read(path):
+    '''Open specified file read-only'''
+    try:
+        orig = codecs.open(path, 'r', "UTF-8")
+    except Exception:
+        raise
+
+    return orig
+
+
+def recursive_rm(dirPath, contents_only=False):
+    '''recursively remove directory'''
+    names = os.listdir(dirPath)
+    for name in names:
+        path = os.path.join(dirPath, name)
+        if os.path.islink(path) or not os.path.isdir(path):
+            os.unlink(path)
+        else:
+            recursive_rm(path)
+    if contents_only is False:
+        os.rmdir(dirPath)
+
+
+def run_check(cls):
+    if len(sys.argv) < 2:
+        error("Must give path to package")
+
+    # extract args
+    fn = sys.argv[1]
+    if len(sys.argv) > 2:
+        overrides = json.loads(sys.argv[2])
+    else:
+        overrides = None
+
+    review = cls(fn, overrides=overrides)
+    review.do_checks()
+    rc = review.do_report()
+    sys.exit(rc)
+
+
+def detect_package(fn, dir=None):
+    '''Detect what type of package this is'''
+    pkgtype = None
+    pkgver = None
+
+    if not os.path.isfile(fn):
+        error("Could not find '%s'" % fn)
+
+    if dir is None:
+        unpack_dir = unpack_pkg(fn)
+    else:
+        unpack_dir = dir
+
+    if not os.path.isdir(unpack_dir):
+        error("Could not find '%s'" % unpack_dir)
+
+    pkg = fn
+    if not pkg.startswith('/'):
+        pkg = os.path.abspath(pkg)
+
+    # check if its a squashfs based snap
+    if is_squashfs(pkg):
+        # 16.04+ squashfs snaps
+        pkgtype = "snap"
+        pkgver = 2
+    elif os.path.exists(os.path.join(unpack_dir, "meta/package.yaml")):
+        # 15.04 ar-based snaps
+        pkgtype = "snap"
+        pkgver = 1
+    else:
+        pkgtype = "click"
+        pkgver = 1
+
+    if dir is None and os.path.isdir(unpack_dir):
+        recursive_rm(unpack_dir)
+
+    return (pkgtype, pkgver)

=== modified file 'clickreviews/cr_bin_path.py'
--- clickreviews/cr_bin_path.py	2015-08-18 16:04:05 +0000
+++ clickreviews/cr_bin_path.py	2016-02-10 19:30:47 +0000
@@ -26,16 +26,19 @@
         # bin-path is ignored by snappy install so don't bother with peerhooks
         ClickReview.__init__(self, fn, "bin-path", overrides=overrides)
 
+        self.bin_paths_files = dict()
+        self.bin_paths = dict()
+
+        if not self.is_snap1:
+            return
+
         # snappy yaml currently only allows specifying:
         # - exec (optional)
         # - description (optional)
         self.required_keys = []
         self.optional_keys = ['description', 'exec'] + self.snappy_exe_security
 
-        self.bin_paths_files = dict()
-        self.bin_paths = dict()
-
-        if self.is_snap and 'binaries' in self.pkg_yaml:
+        if self.is_snap1 and 'binaries' in self.pkg_yaml:
             if len(self.pkg_yaml['binaries']) == 0:
                 error("package.yaml malformed: 'binaries' is empty")
             for binary in self.pkg_yaml['binaries']:
@@ -91,7 +94,7 @@
 
     def check_snappy_required(self):
         '''Check for package.yaml required fields'''
-        if not self.is_snap or 'binaries' not in self.pkg_yaml:
+        if not self.is_snap1 or 'binaries' not in self.pkg_yaml:
             return
         self._verify_required(self._create_dict(self.pkg_yaml['binaries']),
                               'package_yaml')
@@ -121,7 +124,7 @@
 
     def check_snappy_optional(self):
         '''Check snappy packate.yaml optional fields'''
-        if not self.is_snap or 'binaries' not in self.pkg_yaml:
+        if not self.is_snap1 or 'binaries' not in self.pkg_yaml:
             return
         self._verify_optional(self._create_dict(self.pkg_yaml['binaries']),
                               'package_yaml')
@@ -149,13 +152,16 @@
 
     def check_snappy_unknown(self):
         '''Check snappy package.yaml unknown fields'''
-        if not self.is_snap or 'binaries' not in self.pkg_yaml:
+        if not self.is_snap1 or 'binaries' not in self.pkg_yaml:
             return
         self._verify_unknown(self._create_dict(self.pkg_yaml['binaries']),
                              'package_yaml')
 
     def check_path(self):
         '''Check path exists'''
+        if not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('path_exists')
         s = "OK"
@@ -172,7 +178,7 @@
 
     def check_binary_description(self):
         '''Check package.yaml binary description'''
-        if not self.is_snap or 'binaries' not in self.pkg_yaml:
+        if not self.is_snap1 or 'binaries' not in self.pkg_yaml:
             return
 
         my_dict = self._create_dict(self.pkg_yaml['binaries'])

=== modified file 'clickreviews/cr_common.py'
--- clickreviews/cr_common.py	2016-02-01 17:29:56 +0000
+++ clickreviews/cr_common.py	2016-02-10 19:30:47 +0000
@@ -1,6 +1,6 @@
-'''common.py: common classes and functions'''
+'''cr_common.py: common classes and functions'''
 #
-# 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
@@ -15,54 +15,31 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import print_function
-import atexit
-import codecs
 from debian.deb822 import Deb822
 import glob
-import inspect
 import json
-import logging
-import magic
 import os
 import pprint
 import re
-import shutil
-import subprocess
-import sys
-import tempfile
-import types
 import yaml
 
-DEBUGGING = False
-UNPACK_DIR = None
-RAW_UNPACK_DIR = None
-
-
-def cleanup_unpack():
-    global UNPACK_DIR
-    if UNPACK_DIR is not None and os.path.isdir(UNPACK_DIR):
-        recursive_rm(UNPACK_DIR)
-        UNPACK_DIR = None
-    global RAW_UNPACK_DIR
-    if RAW_UNPACK_DIR is not None and os.path.isdir(RAW_UNPACK_DIR):
-        recursive_rm(RAW_UNPACK_DIR)
-        RAW_UNPACK_DIR = None
-atexit.register(cleanup_unpack)
+
+from clickreviews.common import(
+    Review,
+    ReviewException,
+    error,
+    open_file_read,
+)
 
 
 #
 # Utility classes
 #
-class ClickReviewException(Exception):
+class ClickReviewException(ReviewException):
     '''This class represents ClickReview exceptions'''
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return repr(self.value)
-
-
-class ClickReview(object):
+
+
+class ClickReview(Review):
     '''This class represents click reviews'''
     # Convenience to break out common types of clicks (eg, app, scope,
     # click service)
@@ -124,8 +101,13 @@
 
     def __init__(self, fn, review_type, peer_hooks=None, overrides=None,
                  peer_hooks_link=None):
-        self.pkg_filename = fn
-        self._check_path_exists()
+        Review.__init__(self, fn, review_type, overrides=overrides)
+
+        # The cr_* scripts only support 15.04 snaps (v1). Use sr_* scripts for
+        # 16.04 (v2) or higher
+        if not self.is_click and not self.is_snap1:
+            return
+
         if not self.pkg_filename.endswith(".click") and \
                 not self.pkg_filename.endswith(".snap"):
             if self.pkg_filename.endswith(".deb"):
@@ -134,67 +116,24 @@
                       "how click packages are different.")
             error("filename does not end with '.click'")
 
-        self.review_type = review_type
-        self.click_report = dict()
-
-        self.result_types = ['info', 'warn', 'error']
-        for r in self.result_types:
-            self.click_report[r] = dict()
-
-        self.click_report_output = "json"
-
-        global UNPACK_DIR
-        if UNPACK_DIR is None:
-            UNPACK_DIR = unpack_click(fn)
-        self.unpack_dir = UNPACK_DIR
-
-        global RAW_UNPACK_DIR
-        if RAW_UNPACK_DIR is None:
-            RAW_UNPACK_DIR = raw_unpack_pkg(fn)
-        self.raw_unpack_dir = RAW_UNPACK_DIR
-
-        self.pkgfmt = {"type": "", "version": ""}
         self.manifest = None
         self.click_pkgname = None
         self.click_version = None
         self.pkg_arch = []
-
-        # Parse and store the package.yaml, if it exists
-        pkg_yaml = self._extract_package_yaml()
-        snap_yaml = self._extract_snap_yaml()
-        self.is_snap = False
-        if pkg_yaml is None and snap_yaml is None:
-            self.pkgfmt["type"] = "click"
-        else:
-            self.pkgfmt["type"] = "snap"
-            # Some day we will be able to introspect the version, but not
-            # today.... For now, decide on if it is a squashfs and if so,
-            # assume it is 16.04
-            if is_squashfs(fn):
-                self.pkgfmt["version"] = "16.04"
-                self.peer_hooks = None
-                self.peer_hooks_link = None
-            else:
-                self.pkgfmt["version"] = "15.04"
-
-            if snap_yaml:
-                try:
-                    self.snap_yaml = yaml.safe_load(snap_yaml)
-                except Exception:
-                    error("Could not load snap.yaml. Is it properly formatted?")
-                # convert enough of snap_yaml too pkg.yaml to make
-                # the basics of the review tools
-                if self.snap_yaml:
-                    self.pkg_yaml = self.snap_yaml
-                    self.pkg_yaml["version"] = str(self.snap_yaml["version"])
-
+        self.is_snap_oem = False
+        self.peer_hooks = peer_hooks
+        self.peer_hooks_link = peer_hooks_link
+
+        if self.is_snap1:
+            pkg_yaml = self._extract_package_yaml()
             if pkg_yaml:
                 try:
                     self.pkg_yaml = yaml.safe_load(pkg_yaml)
                 except Exception:
                     error("Could not load package.yaml. Is it properly formatted?")
                 self._verify_package_yaml_structure()
-            self.is_snap = True
+            else:
+                error("Could not load package.yaml.")
 
             #  default to 'app'
             if 'type' not in self.pkg_yaml:
@@ -212,7 +151,10 @@
             else:
                 self.pkg_arch = ['all']
 
-        if self._pkgfmt_type() == "click" or self._pkgfmt_version() == "15.04":
+            if 'type' in self.pkg_yaml and self.pkg_yaml['type'] == 'oem':
+                self.is_snap_oem = True
+
+        if self.is_click or self.is_snap1:
             # Get some basic information from the control file
             control_file = self._extract_control_file()
             tmp = list(Deb822.iter_paragraphs(control_file))
@@ -221,7 +163,7 @@
             control = tmp[0]
             self.click_pkgname = control['Package']
             self.click_version = control['Version']
-            if self._pkgfmt_type() == "click":
+            if self.is_click:
                 if control['Architecture'] not in self.pkg_arch:
                     self.pkg_arch.append(control['Architecture'])
                 self.pkgfmt["version"] = str(control['Click-Version'])
@@ -236,33 +178,6 @@
 
             self.valid_frameworks = self._extract_click_frameworks()
 
-            self.peer_hooks = peer_hooks
-            self.peer_hooks_link = peer_hooks_link
-
-        self.is_snap_oem = False
-        if self.is_snap and 'type' in self.pkg_yaml and \
-           self.pkg_yaml['type'] == 'oem':
-            self.is_snap_oem = True
-
-        self.is_snap_gadget = False
-        if self.is_snap and 'type' in self.pkg_yaml and \
-           self.pkg_yaml['type'] == 'gadget':
-            self.is_snap_gadget = True
-
-        # Get a list of all unpacked files, except DEBIAN/
-        self.pkg_files = []
-        self._list_all_files()
-
-        # Setup what is needed to get a list of all unpacked compiled binaries
-        self.mime = magic.open(magic.MAGIC_MIME)
-        self.mime.load()
-        self.pkg_bin_files = []
-        # Don't run this here since only cr_lint.py and cr_functional.py need
-        # it now
-        # self._list_all_compiled_binaries()
-
-        self.overrides = overrides if overrides is not None else {}
-
     def _extract_click_frameworks(self):
         '''Extract installed click frameworks'''
         # TODO: update to use libclick API when available
@@ -291,78 +206,16 @@
             return None  # snappy packaging is still optional
         return open_file_read(y)
 
-    def _extract_snap_yaml(self):
-        '''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)
-
     def _extract_hashes_yaml(self):
         '''Extract and read the snappy hashes.yaml'''
         y = os.path.join(self.unpack_dir, "DEBIAN/hashes.yaml")
         return open_file_read(y)
 
-    def _extract_statinfo(self, fn):
-        '''Extract statinfo from file'''
-        try:
-            st = os.stat(fn)
-        except Exception:
-            return None
-        return st
-
-    def _path_join(self, dirname, rest):
-        return os.path.join(dirname, rest)
-
-    def _get_sha512sum(self, fn):
-        '''Get sha512sum of file'''
-        (rc, out) = cmd(['sha512sum', fn])
-        if rc != 0:
-            return None
-        return out.split()[0]
-
-    def _pkgfmt_type(self):
-        '''Return the package format type'''
-        if "type" not in self.pkgfmt:
-            return ""
-        return self.pkgfmt["type"]
-
-    def _pkgfmt_version(self):
-        '''Return the package format version'''
-        if "version" not in self.pkgfmt:
-            return ""
-        return self.pkgfmt["version"]
-
-    def _check_path_exists(self):
-        '''Check that the provided path exists'''
-        if not os.path.exists(self.pkg_filename):
-            error("Could not find '%s'" % self.pkg_filename)
-
     def _extract_control_file(self):
         '''Extract '''
         fh = open_file_read(os.path.join(self.unpack_dir, "DEBIAN/control"))
         return fh.readlines()
 
-    def _list_all_files(self):
-        '''List all files included in this click package.'''
-        for root, dirnames, filenames in os.walk(self.unpack_dir):
-            for f in filenames:
-                self.pkg_files.append(os.path.join(root, f))
-
-    def _check_if_message_catalog(self, fn):
-        '''Check if file is a message catalog (.mo file).'''
-        if fn.endswith('.mo'):
-            return True
-        return False
-
-    def _list_all_compiled_binaries(self):
-        '''List all compiled binaries in this click package.'''
-        for i in self.pkg_files:
-            res = self.mime.file(i)
-            if res in self.magic_binary_file_descriptions and \
-               not self._check_if_message_catalog(i):
-                self.pkg_bin_files.append(i)
-
     def _verify_manifest_structure(self):
         '''Verify manifest has the expected structure'''
         # lp:click doc/file-format.rst
@@ -506,7 +359,7 @@
 
     def _verify_pkgname(self, n):
         '''Verify package name'''
-        if self.is_snap:
+        if self.is_snap1:
             # snaps can't have '.' in the name
             pat = re.compile(r'^[a-z0-9][a-z0-9+-]+$')
         else:
@@ -515,15 +368,6 @@
             return True
         return False
 
-    def _verify_pkgversion(self, v):
-        '''Verify package name'''
-        re_valid_version = re.compile(r'^((\d+):)?'              # epoch
-                                      '([A-Za-z0-9.+:~-]+?)'     # upstream
-                                      '(-([A-Za-z0-9+.~]+))?$')  # debian
-        if re_valid_version.match(v):
-            return True
-        return False
-
     def _verify_maintainer(self, m):
         '''Verify maintainer email'''
         #  Simple regex as used by python3-debian. If we wanted to be more
@@ -550,7 +394,7 @@
     def check_peer_hooks(self, hooks_sublist=[]):
         '''Check if peer hooks are valid'''
         # Nothing to verify
-        if self.peer_hooks is None:
+        if not hasattr(self, 'peer_hooks') or self.peer_hooks is None:
             return
 
         for hook in self.peer_hooks:
@@ -584,280 +428,3 @@
                                      link=self.peer_hooks_link)
             else:
                 self._add_result(t, n, s)
-
-    def set_review_type(self, name):
-        '''Set review name'''
-        self.review_type = name
-
-    def _get_check_name(self, name, app='', extra=''):
-        name = ':'.join([self.review_type, name])
-        if app:
-            name += ':' + app
-        if extra:
-            name += ':' + extra
-        return name
-
-    # click_report[<result_type>][<review_name>] = <result>
-    #   result_type: info, warn, error
-    #   review_name: name of the check (prefixed with self.review_type)
-    #   result: contents of the review
-    def _add_result(self, result_type, review_name, result, link=None,
-                    manual_review=False):
-        '''Add result to report'''
-        if result_type not in self.result_types:
-            error("Invalid result type '%s'" % result_type)
-
-        if review_name not in self.click_report[result_type]:
-            # log info about check so it can be collected into the
-            # check-names.list file
-            # format should be
-            # CHECK|<review_type:check_name>|<link>
-            msg = 'CHECK|{}|{}'
-            name = ':'.join(review_name.split(':')[:2])
-            link_text = link if link is not None else ""
-            logging.debug(msg.format(name, link_text))
-            self.click_report[result_type][review_name] = dict()
-
-        self.click_report[result_type][review_name].update({
-            'text': result,
-            'manual_review': manual_review,
-        })
-        if link is not None:
-            self.click_report[result_type][review_name]["link"] = link
-
-    def do_report(self):
-        '''Print report'''
-        if self.click_report_output == "console":
-            # TODO: format better
-            import pprint
-            pprint.pprint(self.click_report)
-        elif self.click_report_output == "json":
-            import json
-            msg(json.dumps(self.click_report,
-                           sort_keys=True,
-                           indent=2,
-                           separators=(',', ': ')))
-
-        rc = 0
-        if len(self.click_report['error']):
-            rc = 2
-        elif len(self.click_report['warn']):
-            rc = 1
-        return rc
-
-    def do_checks(self):
-        '''Run all methods that start with check_'''
-        methodList = [name for name, member in
-                      inspect.getmembers(self, inspect.ismethod)
-                      if isinstance(member, types.MethodType)]
-        for methodname in methodList:
-            if not methodname.startswith("check_"):
-                continue
-            func = getattr(self, methodname)
-            func()
-
-
-#
-# Utility functions
-#
-def error(out, exit_code=1, do_exit=True):
-    '''Print error message and exit'''
-    try:
-        print("ERROR: %s" % (out), file=sys.stderr)
-    except IOError:
-        pass
-
-    if do_exit:
-        sys.exit(exit_code)
-
-
-def warn(out):
-    '''Print warning message'''
-    try:
-        print("WARN: %s" % (out), file=sys.stderr)
-    except IOError:
-        pass
-
-
-def msg(out, output=sys.stdout):
-    '''Print message'''
-    try:
-        print("%s" % (out), file=output)
-    except IOError:
-        pass
-
-
-def debug(out):
-    '''Print debug message'''
-    global DEBUGGING
-    if DEBUGGING:
-        try:
-            print("DEBUG: %s" % (out), file=sys.stderr)
-        except IOError:
-            pass
-
-
-def cmd(command):
-    '''Try to execute the given command.'''
-    debug(command)
-    try:
-        sp = subprocess.Popen(command, stdout=subprocess.PIPE,
-                              stderr=subprocess.STDOUT)
-    except OSError as ex:
-        return [127, str(ex)]
-
-    if sys.version_info[0] >= 3:
-        out = sp.communicate()[0].decode('ascii', 'ignore')
-    else:
-        out = sp.communicate()[0]
-
-    return [sp.returncode, out]
-
-
-def cmd_pipe(command1, command2):
-    '''Try to pipe command1 into command2.'''
-    try:
-        sp1 = subprocess.Popen(command1, stdout=subprocess.PIPE)
-        sp2 = subprocess.Popen(command2, stdin=sp1.stdout)
-    except OSError as ex:
-        return [127, str(ex)]
-
-    if sys.version_info[0] >= 3:
-        out = sp2.communicate()[0].decode('ascii', 'ignore')
-    else:
-        out = sp2.communicate()[0]
-
-    return [sp2.returncode, out]
-
-
-def _unpack_cmd(cmd_args, d, dest):
-    '''Low level unpack helper'''
-    curdir = os.getcwd()
-    os.chdir(d)
-
-    (rc, out) = cmd(cmd_args)
-    os.chdir(curdir)
-
-    if rc != 0:
-        if os.path.isdir(d):
-            recursive_rm(d)
-        error("unpacking failed with '%d':\n%s" % (rc, out))
-
-    if dest is None:
-        dest = d
-    else:
-        shutil.move(d, dest)
-
-    return dest
-
-
-def _unpack_snap_squashfs(snap_pkg, dest):
-    '''Unpack a squashfs based snap package to dest'''
-    d = tempfile.mkdtemp(prefix='clickreview-')
-    return _unpack_cmd(['unsquashfs', '-f', '-d', d,
-                        os.path.abspath(snap_pkg)], d, dest)
-
-
-def _unpack_click_deb(click_pkg, dest):
-    d = tempfile.mkdtemp(prefix='clickreview-')
-    return _unpack_cmd(['dpkg-deb', '-R',
-                        os.path.abspath(click_pkg), d], d, dest)
-
-
-def unpack_click(fn, dest=None):
-    '''Unpack click package'''
-    if not os.path.isfile(fn):
-        error("Could not find '%s'" % fn)
-    click_pkg = fn
-    if not click_pkg.startswith('/'):
-        click_pkg = os.path.abspath(click_pkg)
-
-    if dest is not None and os.path.exists(dest):
-        error("'%s' exists. Aborting." % dest)
-
-    # check if its a squashfs based snap
-    if is_squashfs(click_pkg):
-        return _unpack_snap_squashfs(fn, dest)
-
-    return _unpack_click_deb(fn, dest)
-
-
-def is_squashfs(filename):
-    '''Return true if the given filename as a squashfs header'''
-    with open(filename, 'rb') as f:
-        header = f.read(10)
-    return header.startswith(b"hsqs")
-
-
-def raw_unpack_pkg(fn, dest=None):
-    '''Unpack raw package'''
-    if not os.path.isfile(fn):
-        error("Could not find '%s'" % fn)
-    pkg = fn
-    if not pkg.startswith('/'):
-        pkg = os.path.abspath(pkg)
-    # nothing to do for squashfs images
-    if is_squashfs(pkg):
-        return ""
-
-    if dest is not None and os.path.exists(dest):
-        error("'%s' exists. Aborting." % dest)
-
-    d = tempfile.mkdtemp(prefix='review-')
-
-    curdir = os.getcwd()
-    os.chdir(d)
-    (rc, out) = cmd(['ar', 'x', pkg])
-    os.chdir(curdir)
-
-    if rc != 0:
-        if os.path.isdir(d):
-            recursive_rm(d)
-        error("'ar x' failed with '%d':\n%s" % (rc, out))
-
-    if dest is None:
-        dest = d
-    else:
-        shutil.move(d, dest)
-
-    return dest
-
-
-def open_file_read(path):
-    '''Open specified file read-only'''
-    try:
-        orig = codecs.open(path, 'r', "UTF-8")
-    except Exception:
-        raise
-
-    return orig
-
-
-def recursive_rm(dirPath, contents_only=False):
-    '''recursively remove directory'''
-    names = os.listdir(dirPath)
-    for name in names:
-        path = os.path.join(dirPath, name)
-        if os.path.islink(path) or not os.path.isdir(path):
-            os.unlink(path)
-        else:
-            recursive_rm(path)
-    if contents_only is False:
-        os.rmdir(dirPath)
-
-
-def run_click_check(cls):
-    if len(sys.argv) < 2:
-        error("Must give path to click package")
-
-    # extract args
-    fn = sys.argv[1]
-    if len(sys.argv) > 2:
-        overrides = json.loads(sys.argv[2])
-    else:
-        overrides = None
-
-    review = cls(fn, overrides=overrides)
-    review.do_checks()
-    rc = review.do_report()
-    sys.exit(rc)

=== modified file 'clickreviews/cr_content_hub.py'
--- clickreviews/cr_content_hub.py	2015-11-13 23:21:27 +0000
+++ clickreviews/cr_content_hub.py	2016-02-10 19:30:47 +0000
@@ -32,6 +32,8 @@
 
         ClickReview.__init__(self, fn, "content_hub", peer_hooks=peer_hooks,
                              overrides=overrides)
+        if not self.is_click and not self.is_snap1:
+            return
 
         self.valid_keys = ['destination', 'share', 'source']
 
@@ -79,6 +81,9 @@
 
     def check_valid(self):
         '''Check validity of content-hub entries'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.content_hub):
             for k in self.content_hub[app].keys():
                 t = "info"
@@ -109,6 +114,9 @@
 
     def check_unknown_keys(self):
         '''Check unknown'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.content_hub):
             unknown = []
             t = "info"

=== modified file 'clickreviews/cr_desktop.py'
--- clickreviews/cr_desktop.py	2015-11-14 00:08:32 +0000
+++ clickreviews/cr_desktop.py	2016-02-10 19:30:47 +0000
@@ -37,6 +37,8 @@
 
         ClickReview.__init__(self, fn, "desktop", peer_hooks=peer_hooks,
                              overrides=overrides)
+        if not self.is_click and not self.is_snap1:
+            return
 
         self.desktop_files = dict()  # click-show-files and a couple tests
         self.desktop_entries = dict()
@@ -113,6 +115,9 @@
 
     def check_desktop_file(self):
         '''Check desktop file'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('files_usable')
         s = 'OK'
@@ -125,6 +130,9 @@
 
     def check_desktop_file_valid(self):
         '''Check desktop file validates'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -141,6 +149,9 @@
 
     def check_desktop_required_keys(self):
         '''Check for required keys'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -169,6 +180,9 @@
 
     def check_desktop_blacklisted_keys(self):
         '''Check for blacklisted keys'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -185,6 +199,9 @@
 
     def check_desktop_exec(self):
         '''Check Exec entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -218,6 +235,9 @@
 
     def check_desktop_exec_webapp_container(self):
         '''Check Exec=webapp-container entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         if self.manifest is None:
             return
 
@@ -272,6 +292,9 @@
 
     def check_desktop_exec_webbrowser(self):
         '''Check Exec=webbrowser-app entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -307,6 +330,9 @@
 
     def check_desktop_exec_webapp_args(self):
         '''Check Exec=web* args'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -475,6 +501,9 @@
 
     def check_desktop_exec_webbrowser_urlpatterns(self):
         '''Check Exec=webbrowser-app entry has valid --webappUrlPatterns'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             execline = de.getExec().split()
@@ -532,6 +561,9 @@
 
     def check_desktop_exec_webbrowser_modelsearchpath(self):
         '''Check Exec=webbrowser-app entry has valid --webappModelSearchPath'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             execline = de.getExec().split()
@@ -637,6 +669,9 @@
 
     def check_desktop_groups(self):
         '''Check Desktop Entry entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -652,6 +687,9 @@
 
     def check_desktop_type(self):
         '''Check Type entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -667,6 +705,9 @@
 
     def check_desktop_x_ubuntu_touch(self):
         '''Check X-Ubuntu-Touch entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -683,6 +724,9 @@
 
     def check_desktop_x_ubuntu_stagehint(self):
         '''Check X-Ubuntu-StageHint entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -700,6 +744,9 @@
 
     def check_desktop_x_ubuntu_gettext_domain(self):
         '''Check X-Ubuntu-Gettext-Domain entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -722,6 +769,9 @@
 
     def check_desktop_terminal(self):
         '''Check Terminal entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -736,6 +786,9 @@
 
     def check_desktop_version(self):
         '''Check Version entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -754,6 +807,9 @@
 
     def check_desktop_comment(self):
         '''Check Comment entry'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             de = self._get_desktop_entry(app)
             t = 'info'
@@ -769,6 +825,8 @@
 
     def check_desktop_icon(self):
         '''Check Icon entry'''
+        if not self.is_click and not self.is_snap1:
+            return
 
         ICON_SUFFIXES = ['.svg',
                          '.png',
@@ -805,6 +863,9 @@
 
     def check_desktop_duplicate_entries(self):
         '''Check desktop for duplicate entries'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.desktop_entries):
             found = []
             dupes = []

=== modified file 'clickreviews/cr_framework.py'
--- clickreviews/cr_framework.py	2015-11-13 23:21:27 +0000
+++ clickreviews/cr_framework.py	2016-02-10 19:30:47 +0000
@@ -30,6 +30,9 @@
         self.frameworks_file = dict()
         self.frameworks = dict()
 
+        if not self.is_snap1:
+            return
+
         if self.manifest is not None:
             for app in self.manifest['hooks']:
                 if 'framework' not in self.manifest['hooks'][app]:
@@ -98,7 +101,7 @@
 
     def _has_framework_in_metadir(self):
         '''Check if snap has meta/<name>.framework'''
-        if not self.is_snap:
+        if not self.is_snap1:
             return False
 
         return os.path.exists(os.path.join(self.unpack_dir, 'meta',
@@ -107,6 +110,9 @@
 
     def check_framework_hook_obsolete(self):
         '''Check manifest doesn't specify 'framework' hook'''
+        if not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name("obsolete_declaration")
         s = "OK"
@@ -118,7 +124,7 @@
 
     def check_snappy_framework_file_obsolete(self):
         '''Check snap doesn't ship .framework file'''
-        if not self.is_snap or self.pkg_yaml['type'] != 'framework':
+        if not self.is_snap1 or self.pkg_yaml['type'] != 'framework':
             return
         t = 'info'
         n = self._get_check_name("obsolete_framework_file")
@@ -130,7 +136,7 @@
 
     def check_snappy_framework_depends(self):
         '''Check framework doesn't depend on other frameworks'''
-        if not self.is_snap or self.pkg_yaml['type'] != 'framework':
+        if not self.is_snap1 or self.pkg_yaml['type'] != 'framework':
             return
         t = 'info'
         n = self._get_check_name("dependency")
@@ -142,7 +148,7 @@
 
     def check_snappy_framework_policy(self):
         '''Check framework ships at least some policy'''
-        if not self.is_snap or self.pkg_yaml['type'] != 'framework':
+        if not self.is_snap1 or self.pkg_yaml['type'] != 'framework':
             return
 
         t = 'info'
@@ -173,7 +179,7 @@
 
     def check_snappy_framework_policy_metadata(self):
         '''Check framework policy has expected meta data'''
-        if not self.is_snap or self.pkg_yaml['type'] != 'framework':
+        if not self.is_snap1 or self.pkg_yaml['type'] != 'framework':
             return
 
         t = 'info'
@@ -201,7 +207,7 @@
 
     def check_snappy_framework_policy_matching(self):
         '''Check framework policy ships apparmor and seccomp for each'''
-        if not self.is_snap or self.pkg_yaml['type'] != 'framework':
+        if not self.is_snap1 or self.pkg_yaml['type'] != 'framework':
             return
 
         t = 'info'
@@ -231,7 +237,7 @@
 
     def check_snappy_framework_policy_filenames(self):
         '''Check framework policy file names'''
-        if not self.is_snap or self.pkg_yaml['type'] != 'framework':
+        if not self.is_snap1 or self.pkg_yaml['type'] != 'framework':
             return
 
         for i in self.framework_policy:

=== modified file 'clickreviews/cr_functional.py'
--- clickreviews/cr_functional.py	2015-11-20 17:31:36 +0000
+++ clickreviews/cr_functional.py	2016-02-10 19:30:47 +0000
@@ -29,6 +29,8 @@
     '''This class represents click lint reviews'''
     def __init__(self, fn, overrides=None):
         ClickReview.__init__(self, fn, "functional", overrides=overrides)
+        if not self.is_click and not self.is_snap1:
+            return
 
         self.qml_files = []
         for i in self.pkg_files:
@@ -39,6 +41,9 @@
 
     def check_applicationName(self):
         '''Check applicationName matches click manifest'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         if self.manifest is None:
             return
 
@@ -120,6 +125,9 @@
 
     def check_qtwebkit(self):
         '''Check that QML applications don't use QtWebKit'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('qml_application_uses_QtWebKit')
         s = "OK"
@@ -169,6 +177,9 @@
 
     def check_friends(self):
         '''Check that QML applications don't use deprecated Friends API'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('qml_application_uses_friends')
         s = "OK"

=== modified file 'clickreviews/cr_lint.py'
--- clickreviews/cr_lint.py	2016-02-01 19:12:30 +0000
+++ clickreviews/cr_lint.py	2016-02-10 19:30:47 +0000
@@ -26,12 +26,15 @@
 from clickreviews.frameworks import Frameworks
 from clickreviews.cr_common import (
     ClickReview,
+)
+
+from clickreviews.common import (
     open_file_read,
     cmd,
     error,
-    is_squashfs,
 )
 
+
 CONTROL_FILE_NAMES = ["control", "manifest", "preinst"]
 MINIMUM_CLICK_FRAMEWORK_VERSION = "0.4"
 
@@ -42,9 +45,12 @@
     def __init__(self, fn, overrides=None):
         '''Set up the class.'''
         ClickReview.__init__(self, fn, "lint", overrides=overrides)
-        if not self.is_snap and "md5sums" not in CONTROL_FILE_NAMES:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if self.is_click and "md5sums" not in CONTROL_FILE_NAMES:
             CONTROL_FILE_NAMES.append("md5sums")
-        elif self.is_snap:
+        elif self.is_snap1:
             CONTROL_FILE_NAMES.append("hashes.yaml")
         self.control_files = dict()
         self._list_control_files()
@@ -152,8 +158,7 @@
 
     def check_control_files(self):
         '''Check DEBIAN/* files'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         for f in self.control_files:
@@ -162,7 +167,7 @@
                 'DEBIAN_has_files', extra=os.path.basename(f))
             s = "OK"
             if not os.path.isfile(self.control_files[os.path.basename(f)]):
-                if self.is_snap and os.path.basename(f) == 'md5sums':
+                if self.is_snap1 and os.path.basename(f) == 'md5sums':
                     s = "OK (skip md5sums with snap)"
                 else:
                     t = 'error'
@@ -183,8 +188,7 @@
 
     def check_control(self):
         '''Check control()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         fh = self._extract_control_file()
@@ -213,7 +217,7 @@
             n = self._get_check_name('control_has_field', extra=f)
             s = 'OK'
             if f not in control:
-                if f == 'Maintainer' and self.is_snap:
+                if f == 'Maintainer' and self.is_snap1:
                     s = 'OK (maintainer not required for snappy)'
                 else:
                     t = 'error'
@@ -269,7 +273,7 @@
                     s = 'If arch=multi, manifest architecture needs to ' + \
                         'comprise of only compiled architectures.'
             elif control['Architecture'] != self.manifest['architecture'] and \
-                    not self.is_snap:  # snappy doesn't use this field; ignore
+                    not self.is_snap1:  # snappy doesn't use this field; ignore
                 t = 'error'
                 s = "Architecture=%s " % control['Architecture'] + \
                     "does not match manifest architecture=%s" % \
@@ -333,7 +337,7 @@
 
     def check_md5sums(self):
         '''Check md5sums()'''
-        if self.is_snap:
+        if not self.is_click:
             return
         curdir = os.getcwd()
         fh = open_file_read(self.control_files["md5sums"])
@@ -358,8 +362,7 @@
 
     def check_preinst(self):
         '''Check preinst()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         expected = '''#! /bin/sh
@@ -383,17 +386,13 @@
 
     def check_hooks(self):
         '''Check click manifest hooks'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         #  oem snaps don't have a hooks entry
         if self.is_snap_oem:
             return
 
-        if self.is_snap_gadget:
-            return
-
         # Some checks are already handled in
         # cr_common.py:_verify_manifest_structure()
 
@@ -486,17 +485,13 @@
 
     def check_hooks_unknown(self):
         '''Check if have any unknown hooks'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         #  oem snaps don't have a hooks entry
         if self.is_snap_oem:
             return
 
-        if self.is_snap_gadget:
-            return
-
         t = 'info'
         n = self._get_check_name('unknown_hooks')
         s = 'OK'
@@ -514,8 +509,7 @@
 
     def check_hooks_redflagged(self):
         '''Check if have any redflagged hooks'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
@@ -531,7 +525,7 @@
             for hook in self.manifest['hooks'][app]:
                 if hook in self.redflagged_hooks:
                     # This check is handled elsewhere
-                    if self.is_snap and hook == "apparmor-profile":
+                    if self.is_snap1 and hook == "apparmor-profile":
                         continue
                     found.append(hook)
             if len(found) > 0:
@@ -542,7 +536,9 @@
 
     def check_external_symlinks(self):
         '''Check if symlinks in the click package go out to the system.'''
-        if self.is_snap and self.pkg_yaml['type'] not in ['app', 'framework']:
+        if not self.is_click and not self.is_snap1:
+            return
+        if self.is_snap1 and self.pkg_yaml['type'] not in ['app', 'framework']:
             return
 
         t = 'info'
@@ -601,7 +597,7 @@
 
     def check_pkgname(self):
         '''Check click package name valid'''
-        if self.is_snap:
+        if not self.is_click:
             return
         p = self.manifest['name']
         # http://www.debian.org/doc/debian-policy/ch-controlfields.html
@@ -615,8 +611,7 @@
 
     def check_version(self):
         '''Check click package version is valid'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         # deb-version(5)
@@ -634,8 +629,7 @@
 
     def check_architecture(self):
         '''Check click package architecture in DEBIAN/control is valid'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
@@ -648,6 +642,9 @@
 
     def check_architecture_all(self):
         '''Check if actually architecture all'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('control_architecture_valid_contents')
         s = 'OK'
@@ -667,6 +664,9 @@
 
     def check_architecture_specified_needed(self):
         '''Check if the specified architecture is actually needed'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for arch in self.pkg_arch:
             t = 'info'
             n = self._get_check_name('architecture_specified_needed')
@@ -684,15 +684,14 @@
 
     def check_maintainer(self):
         '''Check manifest maintainer()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
         n = self._get_check_name('maintainer_present')
         s = 'OK'
         if 'maintainer' not in self.manifest:
-            if self.is_snap:
+            if self.is_snap1:
                 s = 'Skipped optional maintainer field not specified in ' + \
                     'manifest'
             else:
@@ -704,7 +703,7 @@
 
         # Don't perform maintainer checks for snaps. They aren't used by
         # anything.
-        if self.is_snap:
+        if self.is_snap1:
             return
 
         # Simple regex as used by python3-debian. If we wanted to be more
@@ -728,8 +727,7 @@
 
     def check_title(self):
         '''Check manifest title()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
@@ -752,8 +750,7 @@
 
     def check_description(self):
         '''Check manifest description()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
@@ -771,8 +768,8 @@
         pkgname_base = self.click_pkgname.split('.')[-1]
         if len(self.manifest['description']) < len(pkgname_base):
             t = 'warn'
-            if self.is_snap and (self.manifest['description'] == '\n' or
-                                 self.manifest['description'] == ''):
+            if self.is_snap1 and (self.manifest['description'] == '\n' or
+                                  self.manifest['description'] == ''):
                 s = "manifest description is empty. Is meta/readme.md " + \
                     "formatted correctly?"
             else:
@@ -782,8 +779,7 @@
 
     def check_framework(self):
         '''Check manifest framework()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         n = self._get_check_name('framework')
@@ -791,7 +787,7 @@
         framework_overrides = self.overrides.get('framework', {})
         frameworks = Frameworks(overrides=framework_overrides)
 
-        if not self.is_snap and ',' in self.manifest['framework']:
+        if not self.is_snap1 and ',' in self.manifest['framework']:
             # click doesn't support multiple frameworks yet
             t = 'error'
             s = 'ERROR: multiple frameworks found in click manifest'
@@ -827,8 +823,7 @@
 
     def check_click_local_extensions(self):
         '''Report any click local extensions'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
@@ -855,6 +850,9 @@
 
     def check_vcs(self):
         '''Check for VCS files in the package'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('vcs_files')
         s = 'OK'
@@ -871,7 +869,7 @@
 
     def check_click_in_package(self):
         '''Check for *.click files in the toplevel click package'''
-        if self._pkgfmt_type() == "snap":
+        if not self.is_click:
             return
 
         t = 'info'
@@ -889,8 +887,7 @@
 
     def check_dot_click(self):
         '''Check for .click directory in the toplevel click package'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         t = 'info'
@@ -905,6 +902,9 @@
 
     def check_contents_for_hardcoded_paths(self):
         '''Check for known hardcoded paths.'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         PATH_BLACKLIST = ["/opt/click.ubuntu.com/"]
         t = 'info'
         n = self._get_check_name('hardcoded_paths')
@@ -938,14 +938,14 @@
             return
 
         key = 'architecture'
-        if self.is_snap and 'architectures' in my_dict:
+        if self.is_snap1 and 'architectures' in my_dict:
             # new yaml allows for 'architecture' and 'architectures'
             key = 'architectures'
 
         archs_list = list(self.valid_control_architectures)
         archs_list.remove("multi")
 
-        if self.is_snap and key == 'architectures' and \
+        if self.is_snap1 and key == 'architectures' and \
            isinstance(my_dict[key], str):
             # new yaml uses 'architectures' that must be a list
             t = 'error'
@@ -954,7 +954,7 @@
             t = 'error'
             s = "not a valid architecture: %s" % my_dict[key]
         elif isinstance(my_dict[key], list):
-            if not self.is_snap:
+            if not self.is_snap1:
                 archs_list.remove("all")
             bad_archs = []
             for a in my_dict[key]:
@@ -968,8 +968,7 @@
 
     def check_manifest_architecture(self):
         '''Check package architecture in manifest is valid'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         self._verify_architecture(self.manifest, "manifest")
@@ -1004,15 +1003,14 @@
 
     def check_icon(self):
         '''Check icon()'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         self._verify_icon(self.manifest, "manifest")
 
     def check_snappy_name(self):
         '''Check package name'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         t = 'info'
@@ -1028,7 +1026,7 @@
 
     def check_snappy_version(self):
         '''Check package version'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         t = 'info'
@@ -1044,7 +1042,7 @@
 
     def check_snappy_type(self):
         '''Check type'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         t = 'info'
@@ -1059,7 +1057,7 @@
 
     def check_snappy_type_redflagged(self):
         '''Check if snappy type is redflagged'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         t = 'info'
@@ -1079,14 +1077,14 @@
 
     def check_snappy_icon(self):
         '''Check icon()'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         self._verify_icon(self.pkg_yaml, "package_yaml")
 
     def check_snappy_architecture(self):
         '''Check package architecture in package.yaml is valid'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         self._verify_architecture(self.pkg_yaml, "package yaml")
@@ -1104,7 +1102,7 @@
 
     def check_snappy_unknown_entries(self):
         '''Check for any unknown fields'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         t = 'info'
@@ -1136,10 +1134,7 @@
 
     def check_snappy_readme_md(self):
         '''Check snappy readme.md'''
-        if not self.is_snap:
-            return
-
-        if is_squashfs(self.pkg_filename):
+        if self.is_click or not self.is_snap1:
             return
 
         contents = self._extract_readme_md()
@@ -1163,13 +1158,9 @@
             s = "meta/readme.md is too short"
         self._add_result(t, n, s)
 
-    def _check_innerpath_executable(self, fn):
-        '''Check that the provided path exists and is executable'''
-        return os.access(fn, os.X_OK)
-
     def check_snappy_config(self):
         '''Check snappy config'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
 
         fn = os.path.join(self.unpack_dir, 'meta/hooks/config')
@@ -1186,7 +1177,7 @@
 
     def check_snappy_services_and_binaries(self):
         '''Services and binaries should not overlap'''
-        if not self.is_snap:
+        if self.is_click or not self.is_snap1:
             return
         for exe_t in ['binaries', 'services']:
             if exe_t not in self.pkg_yaml:
@@ -1217,34 +1208,9 @@
                         break
                 self._add_result(t, n, s)
 
-    def check_is_squashfs(self):
-        '''Check snapfs'''
-        if is_squashfs(self.pkg_filename):
-            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_squashfs_uses_snap_yaml(self):
-        '''Ensure that squashfs uses 16.04'''
-        if is_squashfs(self.pkg_filename) and not getattr(self, "snap_yaml"):
-            t = 'error'
-            n = self._get_check_name('check_squashfs_uses_snap_yaml')
-            s = "squashfs snaps must have a meta/snap.yaml"
-            manual_review = False
-            self._add_result(t, n, s, manual_review=manual_review)
-
     def check_snappy_hashes(self):
         '''Check snappy hashes.yaml'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
-            return
-
-        if not self.is_snap:
-            return
-        # no hashes.yaml for squashfs images
-        if is_squashfs(self.pkg_filename):
+        if self.is_click or not self.is_snap1:
             return
 
         def _check_allowed_perms(mode, allowed):

=== modified file 'clickreviews/cr_online_accounts.py'
--- clickreviews/cr_online_accounts.py	2015-12-14 22:00:37 +0000
+++ clickreviews/cr_online_accounts.py	2016-02-10 19:30:47 +0000
@@ -69,6 +69,8 @@
                              peer_hooks=peer_hooks,
                              overrides=overrides,
                              peer_hooks_link="https://wiki.ubuntu.com/SecurityTeam/Specifications/OnlineAccountsConfinement")
+        if not self.is_click and not self.is_snap1:
+            return
 
         self.accounts_files = dict()
         self.accounts = dict()
@@ -164,6 +166,9 @@
 
     def check_hooks_versions(self):
         '''Check hooks versions'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         if self.manifest is None:
             return
 
@@ -247,6 +252,9 @@
 
     def check_manifest(self):
         '''Check manifest'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.accounts.keys()):
             account_type = "accounts"
 
@@ -278,6 +286,9 @@
 
     def check_application(self):
         '''Check application'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.accounts.keys()):
             account_type = "account-application"
 
@@ -325,6 +336,9 @@
 
     def check_service(self):
         '''Check service'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.accounts.keys()):
             account_type = "account-service"
 
@@ -366,6 +380,9 @@
 
     def check_provider(self):
         '''Check provider'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.accounts.keys()):
             account_type = "account-provider"
 
@@ -398,6 +415,9 @@
 
     def check_qml_plugin(self):
         '''Check qml-plugin'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.accounts.keys()):
             account_type = "account-qml-plugin"
 

=== modified file 'clickreviews/cr_push_helper.py'
--- clickreviews/cr_push_helper.py	2015-11-13 23:21:27 +0000
+++ clickreviews/cr_push_helper.py	2016-02-10 19:30:47 +0000
@@ -33,6 +33,9 @@
         ClickReview.__init__(self, fn, "push_helper", peer_hooks=peer_hooks,
                              overrides=overrides)
 
+        if not self.is_click and not self.is_snap1:
+            return
+
         self.required_keys = ['exec']
         self.optional_keys = ['app_id']
 
@@ -81,6 +84,9 @@
 
     def check_valid(self):
         '''Check validity of push-helper entries'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.push_helper):
             for k in self.push_helper[app].keys():
                 t = "info"
@@ -106,6 +112,9 @@
 
     def check_unknown_keys(self):
         '''Check unknown'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.push_helper):
             unknown = []
             t = "info"
@@ -125,6 +134,9 @@
 
     def check_hooks(self):
         '''Verify combinations of click hooks with the push-helper hook'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         if self.manifest is None:
             return
 

=== modified file 'clickreviews/cr_scope.py'
--- clickreviews/cr_scope.py	2015-12-01 14:45:21 +0000
+++ clickreviews/cr_scope.py	2016-02-10 19:30:47 +0000
@@ -40,6 +40,9 @@
         ClickReview.__init__(self, fn, "scope", peer_hooks=peer_hooks,
                              overrides=overrides)
 
+        if not self.is_click and not self.is_snap1:
+            return
+
         self.scopes = dict()
 
         if self.manifest is None:
@@ -85,6 +88,9 @@
 
     def check_scope_ini(self):
         '''Check scope .ini file'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.scopes.keys()):
             t = 'info'
             n = self._get_check_name('ini_scope_section', app=app)

=== modified file 'clickreviews/cr_security.py'
--- clickreviews/cr_security.py	2015-12-14 22:05:53 +0000
+++ clickreviews/cr_security.py	2016-02-10 19:30:47 +0000
@@ -47,6 +47,9 @@
         ClickReview.__init__(self, fn, "security", peer_hooks=peer_hooks,
                              overrides=overrides)
 
+        if not self.is_click and not self.is_snap1:
+            return
+
         # If local_copy is None, then this will check the server to see if
         # we are up to date. However, if we are working within the development
         # tree, use it unconditionally.
@@ -141,7 +144,7 @@
         self.security_profiles = dict()
         self.security_apps_profiles = []
 
-        if self.manifest is None and self.is_snap:
+        if self.manifest is None and self.is_snap1:
             for exe_t in ['services', 'binaries']:
                 if exe_t not in self.pkg_yaml:
                     continue
@@ -265,30 +268,19 @@
 
     def _get_security_manifest(self, app):
         '''Get the security manifest for app'''
-        if self._pkgfmt_type() == "click" or self._pkgfmt_version() == "15.04":
-            if app not in self.manifest['hooks']:
-                error("Could not find '%s' in click manifest" % app)
-            elif 'apparmor' not in self.manifest['hooks'][app]:
-                error("Could not find apparmor hook for '%s' in click manifest" %
-                      app)
-            f = self.manifest['hooks'][app]['apparmor']
-            m = self.security_manifests[f]
-        else:
-            f = app
-            m = self.security_manifests[app]
+        if app not in self.manifest['hooks']:
+            error("Could not find '%s' in click manifest" % app)
+        elif 'apparmor' not in self.manifest['hooks'][app]:
+            error("Could not find apparmor hook for '%s' in click manifest" %
+                  app)
+        f = self.manifest['hooks'][app]['apparmor']
+        m = self.security_manifests[f]
 
         return (f, m)
 
     def _extract_security_profile(self, app):
         '''Extract security profile'''
-        if self._pkgfmt_type() == "click" or self._pkgfmt_version() == "15.04":
-            rel_fn = self.manifest['hooks'][app]['apparmor-profile']
-        else:
-            exe_t, name = app.split('/')
-            for item in self.pkg_yaml[exe_t]:
-                if 'name' in item and item['name'] == name:
-                    rel_fn = item['security-policy']['apparmor']
-                    break
+        rel_fn = self.manifest['hooks'][app]['apparmor-profile']
 
         fn = os.path.join(self.unpack_dir, rel_fn)
         if not os.path.exists(fn):
@@ -308,19 +300,12 @@
 
     def _get_security_profile(self, app):
         '''Get the security profile for app'''
-        if self._pkgfmt_type() == "click" or self._pkgfmt_version() == "15.04":
-            if app not in self.manifest['hooks']:
-                error("Could not find '%s' in click manifest" % app)
-            elif 'apparmor-profile' not in self.manifest['hooks'][app]:
-                error("Could not find apparmor-profile hook for '%s' in click "
-                      "manifest" % app)
-            f = self.manifest['hooks'][app]['apparmor-profile']
-        else:
-            exe_t, name = app.split('/')
-            for item in self.pkg_yaml[exe_t]:
-                if 'name' in item and item['name'] == name:
-                    f = item['security-policy']['apparmor']
-                    break
+        if app not in self.manifest['hooks']:
+            error("Could not find '%s' in click manifest" % app)
+        elif 'apparmor-profile' not in self.manifest['hooks'][app]:
+            error("Could not find apparmor-profile hook for '%s' in click "
+                  "manifest" % app)
+        f = self.manifest['hooks'][app]['apparmor-profile']
 
         p = self.security_profiles[f]
         return (f, p)
@@ -394,6 +379,9 @@
 
     def check_policy_vendor(self):
         '''Check policy_vendor'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
             t = 'info'
@@ -405,10 +393,6 @@
                 s = "policy_vendor '%s' not found" % m['policy_vendor']
             self._add_result(t, n, s)
 
-            if self._pkgfmt_type() == "snap" and \
-                    float(self._pkgfmt_version()) >= 16.04:
-                continue
-
             t = 'info'
             n = self._get_check_name('policy_vendor_matches_framework', extra=f)
             s = "OK"
@@ -418,7 +402,7 @@
                     framework = self.manifest['framework']
                     # snappy compat manifest supports comma-separated list
                     # for framework
-                    if self.is_snap and ',' in framework:
+                    if self.is_snap1 and ',' in framework:
                         # For now, we know the release framework is appended.
                         # TODO: fix for multiple frameworks
                         framework = framework.split(',')[-1]
@@ -440,6 +424,9 @@
 
     def check_policy_version(self):
         '''Check policy version'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -474,10 +461,6 @@
                 s = '%s != %s' % (str(m['policy_version']), str(highest))
             self._add_result(t, n, s, l)
 
-            if self._pkgfmt_type() == "snap" and \
-                    float(self._pkgfmt_version()) >= 16.04:
-                continue
-
             t = 'info'
             n = self._get_check_name('policy_version_matches_framework', extra=f)
             s = "OK"
@@ -486,7 +469,7 @@
                 framework = self.manifest['framework']
                 # snappy compat manifest supports comma-separated list
                 # for framework
-                if self.is_snap and ',' in framework:
+                if self.is_snap1 and ',' in framework:
                     # For now, we know the release framework is appended.
                     # TODO: fix for multiple frameworks
                     framework = framework.split(',')[-1]
@@ -506,6 +489,9 @@
 
     def check_template(self):
         '''Check template'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -556,7 +542,7 @@
             found = False
             if m['template'] in self._get_templates(vendor, version):
                 found = True
-            elif self.is_snap:
+            elif self.is_snap1:
                 frameworks = []
                 if 'framework' in self.pkg_yaml:
                     frameworks = [x.strip() for x in
@@ -581,6 +567,9 @@
 
     def check_policy_groups_webapps(self):
         '''Check policy_groups for webapps'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
             t = 'info'
@@ -617,6 +606,9 @@
 
     def check_policy_groups_push_helpers(self):
         '''Check policy groups for push-helpers'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
             t = 'info'
@@ -647,6 +639,9 @@
 
     def check_policy_groups_scopes(self):
         '''Check policy_groups for scopes'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
             t = 'info'
@@ -680,6 +675,9 @@
 
     def check_policy_groups_ubuntu_account_plugin(self):
         '''Check policy_groups for ubuntu-account-plugin template'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -719,6 +717,9 @@
 
     def check_policy_groups(self):
         '''Check policy_groups'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -762,7 +763,7 @@
             self._add_result(t, n, s)
 
             frameworks = []
-            if self.is_snap:
+            if self.is_snap1:
                 if 'framework' in self.pkg_yaml:
                     frameworks = [x.strip() for x in
                                   self.pkg_yaml['framework'].split(',')]
@@ -841,6 +842,9 @@
 
     def check_ignored(self):
         '''Check ignored fields'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -859,6 +863,9 @@
 
     def check_redflag(self):
         '''Check redflag fields'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -881,6 +888,9 @@
 
     def check_required(self):
         '''Check required fields'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps):
             (f, m) = self._get_security_manifest(app)
 
@@ -899,6 +909,9 @@
 
     def check_apparmor_profile(self):
         '''Check apparmor-profile'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.security_apps_profiles):
             (f, p) = self._get_security_profile(app)
 
@@ -908,9 +921,6 @@
                         '@{APP_PKGNAME}',
                         '@{APP_VERSION}',
                         ]
-            if self._pkgfmt_type() == 'snap' and \
-                    float(self._pkgfmt_version()) > 15.04:
-                searches.append("@{INSTALL_DIR}")
 
             for v in searches:
                 t = 'info'
@@ -1145,9 +1155,10 @@
         '''Verify click and security yaml are in sync (not including
            override)
         '''
-        if not self.is_snap or \
-                self.pkg_yaml['type'] in self.sec_skipped_types or \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if self.is_click or self.pkg_yaml['type'] in self.sec_skipped_types:
             return
 
         # setup a small dict that is a subset of self.pkg_yaml
@@ -1187,9 +1198,10 @@
 
     def check_security_yaml_override_and_click(self):
         '''Verify click and security yaml override are in sync'''
-        if not self.is_snap or \
-                self.pkg_yaml['type'] in self.sec_skipped_types or \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if self.is_click or self.pkg_yaml['type'] in self.sec_skipped_types:
             return
 
         for exe_t in ['services', 'binaries']:
@@ -1226,7 +1238,10 @@
 
     def check_security_yaml_override(self):
         '''Verify security yaml override'''
-        if not self.is_snap:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if not self.is_snap1:
             return
 
         for exe_t in ['services', 'binaries']:
@@ -1248,7 +1263,7 @@
                 s = "OK"
                 if 'security-override' not in item:
                     s = "OK (skipping unspecified override)"
-                elif float(self._pkgfmt_version()) < 16.04:
+                else:
                     if 'apparmor' not in item['security-override']:
                         t = 'error'
                         s = "'apparmor' not specified in 'security-override' " + \
@@ -1257,38 +1272,15 @@
                         t = 'error'
                         s = "'seccomp' not specified in 'security-override' " + \
                             "for '%s'" % app
-                else:
-                    allowed_fields = ['read-paths',
-                                      'write-paths',
-                                      'abstractions',
-                                      'syscalls']
-                    if len(item['security-override'].keys()) == 0:
-                        t = 'error'
-                        s = "nothing specified in 'security-override' " + \
-                            "for '%s'" % app
-                    else:
-                        for f in item['security-override'].keys():
-                            if f not in allowed_fields:
-                                t = 'error'
-                                s = "unknown field '%s' in " % f + \
-                                    "'security-override' for '%s'" % app
 
                 self._add_result(t, n, s)
 
-                # security-override on 16.04 gives direct access to syscalls,
-                # read-paths, etc so it always needs a manual override
-                if 'security-override' in item and \
-                        float(self._pkgfmt_version()) > 15.04:
-                    t = 'error'
-                    n = self._get_check_name('yaml_override_present')
-                    s = "(NEEDS REVIEW) 'security-override' not allowed"
-                    l = 'https://developer.ubuntu.com/en/snappy/guides/security-policy/'
-                    m = True
-                    self._add_result(t, n, s, link=l, manual_review=m)
-
     def check_security_yaml_policy(self):
         '''Verify security yaml policy'''
-        if not self.is_snap:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if not self.is_snap1:
             return
 
         for exe_t in ['services', 'binaries']:
@@ -1330,7 +1322,10 @@
 
     def check_security_yaml_combinations(self):
         '''Verify security yaml uses valid combinations'''
-        if not self.is_snap or self.pkg_yaml['type'] in self.sec_skipped_types:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if not self.is_snap1 or self.pkg_yaml['type'] in self.sec_skipped_types:
             return
 
         for exe_t in ['services', 'binaries']:
@@ -1367,7 +1362,10 @@
 
     def check_security_template(self):
         '''Check snap security-template'''
-        if not self.is_snap or self.pkg_yaml['type'] in self.sec_skipped_types:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if not self.is_snap1 or self.pkg_yaml['type'] in self.sec_skipped_types:
             return
 
         for exe_t in ['services', 'binaries']:
@@ -1401,7 +1399,7 @@
                     continue
                 self._add_result(t, n, s)
 
-                if self._pkgfmt_version() == "15.04":
+                if self.is_snap1:
                     t = 'info'
                     n = self._get_check_name('yaml_security-template_in_manifest', app=app)
                     s = "OK"
@@ -1421,7 +1419,10 @@
 
     def check_security_caps(self):
         '''Check snap caps'''
-        if not self.is_snap or self.pkg_yaml['type'] in self.sec_skipped_types:
+        if not self.is_click and not self.is_snap1:
+            return
+
+        if not self.is_snap1 or self.pkg_yaml['type'] in self.sec_skipped_types:
             return
 
         for exe_t in ['services', 'binaries']:
@@ -1455,7 +1456,7 @@
                     continue
                 self._add_result(t, n, s)
 
-                if self._pkgfmt_version() == "15.04":
+                if self.is_snap1:
                     t = 'info'
                     n = self._get_check_name('yaml_caps_in_manifest', app=app)
                     s = "OK"
@@ -1475,8 +1476,7 @@
 
     def check_template_online_accounts_provider(self):
         '''Check template for online accounts account-provider'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         for app in sorted(self.security_apps):
@@ -1493,8 +1493,7 @@
 
     def check_template_online_accounts_qml_plugin(self):
         '''Check template for online accounts account-qml-plugin'''
-        if self._pkgfmt_type() == "snap" and \
-                float(self._pkgfmt_version()) > 15.04:
+        if not self.is_click and not self.is_snap1:
             return
 
         for app in sorted(self.security_apps):
@@ -1511,6 +1510,9 @@
 
     def check_apparmor_profile_name_length(self):
         '''Check AppArmor profile name length'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         # There are quite a few kernel interfaces that can cause problems with
         # long profile names. These are outlined in
         # https://launchpad.net/bugs/1499544. The big issue is that the audit

=== modified file 'clickreviews/cr_skeleton.py'
--- clickreviews/cr_skeleton.py	2015-08-18 16:05:06 +0000
+++ clickreviews/cr_skeleton.py	2016-02-10 19:30:47 +0000
@@ -34,11 +34,17 @@
         ClickReview.__init__(self, fn, "skeleton", peer_hooks=peer_hooks,
                              overrides=overrides)
 
+        if not self.is_click and not self.is_snap1:
+            return
+
         # If not a hooks test, skip the above and omit peer_hooks like so:
         # ClickReview.__init__(self, fn, "skeleton")
 
     def check_foo(self):
         '''Check foo'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('foo')
         s = "OK"
@@ -49,6 +55,9 @@
 
     def check_bar(self):
         '''Check bar'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         t = 'info'
         n = self._get_check_name('bar')
         s = "OK"
@@ -59,6 +68,9 @@
 
     def check_baz(self):
         '''Check baz'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         n = self._get_check_name('baz')
         self._add_result('warn', n, 'TODO', link="http://example.com")
 

=== modified file 'clickreviews/cr_systemd.py'
--- clickreviews/cr_systemd.py	2015-11-11 16:05:23 +0000
+++ clickreviews/cr_systemd.py	2016-02-10 19:30:47 +0000
@@ -27,6 +27,12 @@
         # systemd isn't implemented as a hook any more so don't setup peerhooks
         ClickReview.__init__(self, fn, "snappy-systemd", overrides=overrides)
 
+        self.systemd_files = dict()  # click-show-files and tests
+        self.systemd = dict()
+
+        if not self.is_snap1:
+            return
+
         # snappy-systemd currently only allows specifying:
         # - start (required)
         # - description (required)
@@ -49,10 +55,7 @@
                               'ports'
                               ] + self.snappy_exe_security
 
-        self.systemd_files = dict()  # click-show-files and tests
-        self.systemd = dict()
-
-        if self.is_snap and 'services' in self.pkg_yaml:
+        if self.is_snap1 and 'services' in self.pkg_yaml:
             if len(self.pkg_yaml['services']) == 0:
                 error("package.yaml malformed: 'services' is empty")
             for service in self.pkg_yaml['services']:
@@ -91,7 +94,7 @@
 
     def check_snappy_required(self):
         '''Check for package.yaml required fields'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_required(self._create_dict(self.pkg_yaml['services']),
                               'package_yaml')
@@ -141,7 +144,7 @@
 
     def check_snappy_optional(self):
         '''Check snappy packate.yaml optional fields'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_optional(self._create_dict(self.pkg_yaml['services']),
                               'package_yaml')
@@ -168,7 +171,7 @@
 
     def check_snappy_unknown(self):
         '''Check snappy package.yaml unknown fields'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_unknown(self._create_dict(self.pkg_yaml['services']),
                              'package_yaml')
@@ -195,7 +198,7 @@
 
     def check_snappy_service_description(self):
         '''Check snappy package.yaml description'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_service_description(self._create_dict(
                                          self.pkg_yaml['services']),
@@ -226,21 +229,21 @@
 
     def check_snappy_service_start(self):
         '''Check snappy package.yaml start'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_entry(self._create_dict(self.pkg_yaml['services']),
                            'start', 'package_yaml')
 
     def check_snappy_service_stop(self):
         '''Check snappy package.yaml stop'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_entry(self._create_dict(self.pkg_yaml['services']),
                            'stop', 'package_yaml')
 
     def check_snappy_service_poststop(self):
         '''Check snappy package.yaml poststop'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_entry(self._create_dict(self.pkg_yaml['services']),
                            'poststop', 'package_yaml')
@@ -282,7 +285,7 @@
 
     def check_snappy_service_stop_timeout(self):
         '''Check snappy package.yaml stop-timeout'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_service_stop_timeout(self._create_dict(
                                           self.pkg_yaml['services']),
@@ -343,7 +346,7 @@
 
     def check_snappy_service_bus_name(self):
         '''Check snappy package.yaml bus-name'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         is_framework = False
         if 'type' in self.pkg_yaml and self.pkg_yaml['type'] == 'framework':
@@ -455,7 +458,7 @@
 
     def check_snappy_service_ports(self):
         '''Check snappy package.yaml ports'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
         self._verify_service_ports(self.pkg_yaml['name'],
                                    self._create_dict(
@@ -512,7 +515,7 @@
 
     def check_snappy_service_listen_stream(self):
         '''Check snappy package.yaml listen-stream'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
 
         self._verify_service_listen_stream(self.pkg_yaml['name'],
@@ -522,7 +525,7 @@
 
     def check_snappy_service_socket_user(self):
         '''Check snappy package.yaml socket-user'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
 
         my_dict = self._create_dict(self.pkg_yaml['services'])
@@ -557,7 +560,7 @@
 
     def check_snappy_service_socket_group(self):
         '''Check snappy package.yaml socket-group'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
 
         my_dict = self._create_dict(self.pkg_yaml['services'])
@@ -592,7 +595,7 @@
 
     def check_snappy_service_socket(self):
         '''Check snappy package.yaml socket'''
-        if not self.is_snap or 'services' not in self.pkg_yaml:
+        if not self.is_snap1 or 'services' not in self.pkg_yaml:
             return
 
         my_dict = self._create_dict(self.pkg_yaml['services'])

=== modified file 'clickreviews/cr_tests.py'
--- clickreviews/cr_tests.py	2016-02-01 17:29:56 +0000
+++ clickreviews/cr_tests.py	2016-02-10 19:30:47 +0000
@@ -25,13 +25,12 @@
 from unittest import TestCase
 
 from clickreviews.cr_lint import MINIMUM_CLICK_FRAMEWORK_VERSION
-import clickreviews.cr_common as cr_common
+import clickreviews.common as common
 
 # These should be set in the test cases
 TEST_CONTROL = ""
 TEST_MANIFEST = ""
 TEST_PKG_YAML = ""
-TEST_SNAP_YAML = ""
 TEST_HASHES_YAML = ""
 TEST_README_MD = ""
 TEST_SECURITY = dict()
@@ -78,11 +77,6 @@
     return io.StringIO(TEST_PKG_YAML)
 
 
-def _extract_snap_yaml(self):
-    '''Pretend we read the package.yaml file'''
-    return io.StringIO(TEST_SNAP_YAML)
-
-
 def _extract_hashes_yaml(self):
     '''Pretend we read the hashes.yaml file'''
     return io.StringIO(TEST_HASHES_YAML)
@@ -95,7 +89,7 @@
 
 def _get_sha512sum(self, fn):
     '''Pretend we found performed a sha512'''
-    (rc, out) = cr_common.cmd(['sha512sum', os.path.realpath(__file__)])
+    (rc, out) = common.cmd(['sha512sum', os.path.realpath(__file__)])
     if rc != 0:
         return None
     return out.split()[0]
@@ -147,9 +141,6 @@
 
 def _get_security_manifest(self, app):
     '''Pretend we read the security manifest file'''
-    if TEST_PKGFMT_VERSION == "16.04":
-        return (app, json.loads(TEST_SECURITY[app]))
-
     return ("%s.apparmor" % app, json.loads(TEST_SECURITY[app]))
 
 
@@ -265,9 +256,12 @@
     return TEST_PKGFMT_VERSION
 
 
-def _is_squashfs(self):
-    '''Pretend we discovered if it is a squashfs or not'''
-    return (TEST_PKGFMT_TYPE == "snap" and float(TEST_PKGFMT_VERSION) > 15.04)
+def _detect_package(self, fn):
+    '''Pretend we detected the package'''
+    ver = 1
+    if TEST_PKGFMT_TYPE == "snap" and TEST_PKGFMT_VERSION != "15.04":
+        ver = 2
+    return (TEST_PKGFMT_TYPE, ver)
 
 
 def create_patches():
@@ -275,7 +269,7 @@
     # Mock patching. Don't use decorators but instead patch in setUp() of the
     # child.
     patches = []
-    patches.append(patch('clickreviews.cr_common.ClickReview._check_path_exists',
+    patches.append(patch('clickreviews.common.Review._check_package_exists',
                    _mock_func))
     patches.append(patch(
         'clickreviews.cr_common.ClickReview._extract_control_file',
@@ -287,45 +281,34 @@
         'clickreviews.cr_common.ClickReview._extract_package_yaml',
         _extract_package_yaml))
     patches.append(patch(
-        'clickreviews.cr_common.ClickReview._extract_snap_yaml',
-        _extract_snap_yaml))
-    patches.append(patch(
         'clickreviews.cr_common.ClickReview._extract_hashes_yaml',
         _extract_hashes_yaml))
-    patches.append(patch(
-        'clickreviews.cr_common.ClickReview._path_join',
-        _path_join))
-    patches.append(patch(
-        'clickreviews.cr_common.ClickReview._get_sha512sum',
-        _get_sha512sum))
-    patches.append(patch(
-        'clickreviews.cr_common.ClickReview._extract_statinfo',
-        _extract_statinfo))
+    patches.append(patch('clickreviews.common.Review._path_join', _path_join))
+    patches.append(patch(
+        'clickreviews.common.Review._get_sha512sum', _get_sha512sum))
+    patches.append(patch(
+        'clickreviews.common.Review._extract_statinfo', _extract_statinfo))
     patches.append(patch(
         'clickreviews.cr_common.ClickReview._extract_click_frameworks',
         _extract_click_frameworks))
-    patches.append(patch('clickreviews.cr_common.unpack_click', _mock_func))
-    patches.append(patch('clickreviews.cr_common.raw_unpack_pkg', _mock_func))
-    patches.append(patch('clickreviews.cr_common.ClickReview._list_all_files',
+    patches.append(patch('clickreviews.common.unpack_pkg', _mock_func))
+    patches.append(patch('clickreviews.common.raw_unpack_pkg', _mock_func))
+    patches.append(patch('clickreviews.common.detect_package',
+                   _detect_package))
+    patches.append(patch('clickreviews.common.Review._list_all_files',
                    _mock_func))
     patches.append(patch(
-        'clickreviews.cr_common.ClickReview._list_all_compiled_binaries',
-        _mock_func))
+        'clickreviews.common.Review._list_all_compiled_binaries', _mock_func))
 
     # lint overrides
     patches.append(patch(
                    'clickreviews.cr_lint.ClickReviewLint._list_control_files',
                    _mock_func))
-    patches.append(patch('clickreviews.cr_lint.ClickReviewLint._list_all_files',
-                   _mock_func))
-    patches.append(patch(
-        'clickreviews.cr_lint.ClickReview._list_all_compiled_binaries',
-        _mock_func))
     patches.append(patch(
         'clickreviews.cr_lint.ClickReviewLint._extract_readme_md',
         _extract_readme_md))
     patches.append(patch(
-        'clickreviews.cr_lint.ClickReviewLint._check_innerpath_executable',
+        'clickreviews.common.Review._check_innerpath_executable',
         _check_innerpath_executable))
 
     # security overrides
@@ -398,12 +381,10 @@
         _has_framework_in_metadir))
 
     # pkgfmt
-    patches.append(patch("clickreviews.cr_common.ClickReview._pkgfmt_type",
+    patches.append(patch("clickreviews.common.Review._pkgfmt_type",
                    _pkgfmt_type))
-    patches.append(patch("clickreviews.cr_common.ClickReview._pkgfmt_version",
+    patches.append(patch("clickreviews.common.Review._pkgfmt_version",
                    _pkgfmt_version))
-    patches.append(patch("clickreviews.cr_common.is_squashfs", _is_squashfs))
-    patches.append(patch("clickreviews.cr_lint.is_squashfs", _is_squashfs))
 
     return patches
 
@@ -457,8 +438,6 @@
                                [self.test_control['Architecture']])
         self._update_test_pkg_yaml()
 
-        self.test_snap_yaml = dict()
-
         self.test_hashes_yaml = dict()
         self._update_test_hashes_yaml()
 
@@ -577,12 +556,6 @@
                                   default_flow_style=False,
                                   indent=4)
 
-    def _update_test_snap_yaml(self):
-        global TEST_SNAP_YAML
-        TEST_SNAP_YAML = yaml.dump(self.test_snap_yaml,
-                                   default_flow_style=False,
-                                   indent=4)
-
     def _update_test_hashes_yaml(self):
         global TEST_HASHES_YAML
         TEST_HASHES_YAML = yaml.dump(self.test_hashes_yaml,
@@ -811,16 +784,6 @@
             self.test_pkg_yaml[key] = value
         self._update_test_pkg_yaml()
 
-    def set_test_snap_yaml(self, key, value):
-        '''Set key in meta/snap.yaml to value. If value is None, remove
-           key'''
-        if value is None:
-            if key in self.test_snap_yaml:
-                self.test_snap_yaml.pop(key, None)
-        else:
-            self.test_snap_yaml[key] = value
-        self._update_test_snap_yaml()
-
     def set_test_hashes_yaml(self, yaml):
         '''Set hashes.yaml to yaml'''
         self.test_hashes_yaml = yaml
@@ -1164,8 +1127,6 @@
         TEST_MANIFEST = ""
         global TEST_PKG_YAML
         TEST_PKG_YAML = ""
-        global TEST_SNAP_YAML
-        TEST_SNAP_YAML = ""
         global TEST_HASHES_YAML
         TEST_HASHES_YAML = ""
         global TEST_README_MD
@@ -1208,4 +1169,4 @@
         TEST_PKGFMT_VERSION = "0.4"
 
         self._reset_test_data()
-        cr_common.recursive_rm(self.desktop_tmpdir)
+        common.recursive_rm(self.desktop_tmpdir)

=== modified file 'clickreviews/cr_url_dispatcher.py'
--- clickreviews/cr_url_dispatcher.py	2015-12-04 14:17:55 +0000
+++ clickreviews/cr_url_dispatcher.py	2016-02-10 19:30:47 +0000
@@ -35,6 +35,9 @@
         ClickReview.__init__(self, fn, "url_dispatcher", peer_hooks=peer_hooks,
                              overrides=overrides)
 
+        if not self.is_click and not self.is_snap1:
+            return
+
         self.required_keys = ['protocol']
         self.optional_keys = ['domain-suffix']
 
@@ -86,6 +89,9 @@
 
     def check_required(self):
         '''Check url-dispatcher required fields'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.url_dispatcher):
             for r in self.required_keys:
                 found = False
@@ -114,6 +120,9 @@
 
     def check_optional(self):
         '''Check url-dispatcher optional fields'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.url_dispatcher):
             for o in self.optional_keys:
                 found = False
@@ -141,6 +150,9 @@
 
     def check_unknown(self):
         '''Check url-dispatcher unknown fields'''
+        if not self.is_click and not self.is_snap1:
+            return
+
         for app in sorted(self.url_dispatcher):
             unknown = []
             for entry in self.url_dispatcher[app]:

=== modified file 'clickreviews/modules.py'
--- clickreviews/modules.py	2015-08-14 08:21:49 +0000
+++ clickreviews/modules.py	2016-02-10 19:30:47 +0000
@@ -4,7 +4,7 @@
 import os
 import pkgutil
 
-IRRELEVANT_MODULES = ['cr_common', 'cr_tests', 'cr_skeleton']
+IRRELEVANT_MODULES = ['cr_common', 'cr_tests', 'cr_skeleton', 'common']
 
 
 def narrow_down_modules(modules):
@@ -49,14 +49,14 @@
 
     classes = inspect.getmembers(module, inspect.isclass)
 
-    def find_cr_class(a):
+    def find_test_class(a):
         return a[0].startswith('Click') and \
             not a[0].endswith('Exception') and \
             a[1].__module__ == module_name
-    cr_class = list(filter(find_cr_class, classes))
-    if not cr_class:
+    test_class = list(filter(find_test_class, classes))
+    if not test_class:
         return None
-    init_object = getattr(module, cr_class[0][0])
+    init_object = getattr(module, test_class[0][0])
     return init_object
 
 

=== modified file 'clickreviews/tests/test_cr_bin_path.py'
--- clickreviews/tests/test_cr_bin_path.py	2015-10-16 02:54:07 +0000
+++ clickreviews/tests/test_cr_bin_path.py	2016-02-10 19:30:47 +0000
@@ -19,7 +19,10 @@
 
 
 class TestClickReviewBinPath(cr_tests.TestClickReview):
-    """Tests for the lint review tool."""
+    """Tests for the bin-path review tool."""
+    def setUp(self):
+        super().setUp()
+        self.set_test_pkgfmt("snap", "15.04")
 
     def _set_binary(self, entries, name=None):
         d = dict()

=== modified file 'clickreviews/tests/test_cr_content_hub.py'
--- clickreviews/tests/test_cr_content_hub.py	2015-11-20 19:11:26 +0000
+++ clickreviews/tests/test_cr_content_hub.py	2016-02-10 19:30:47 +0000
@@ -167,16 +167,3 @@
         r = c.click_report
         expected_counts = {'info': 6, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
-
-    def test_check_valid_snappy_1604(self):
-        '''Test check_valid() - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_content_hub(self.default_appname, "destination", "pictures")
-        self.set_test_content_hub(self.default_appname, "share", "pictures")
-        self.set_test_content_hub(self.default_appname, "source", "pictures")
-        c = ClickReviewContentHub(self.test_name)
-        c.check_valid()
-        r = c.click_report
-        # should be empty with this pkgfmt
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)

=== modified file 'clickreviews/tests/test_cr_desktop.py'
--- clickreviews/tests/test_cr_desktop.py	2015-11-20 19:10:01 +0000
+++ clickreviews/tests/test_cr_desktop.py	2016-02-10 19:30:47 +0000
@@ -910,17 +910,3 @@
         name = c._get_check_name('files_usable')
         expected['info'][name] = {"text": "OK"}
         self.check_results(r, expected=expected)
-
-    def test_check_desktop_file_snappy_1604(self):
-        '''Test check_desktop_file() -  snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        c = ClickReviewDesktop(self.test_name)
-        c.check_desktop_file()
-        r = c.click_report
-        expected = dict()
-        expected['info'] = dict()
-        expected['warn'] = dict()
-        expected['error'] = dict()
-        name = c._get_check_name('files_usable')
-        expected['info'][name] = {"text": "Skipped: could not find any desktop files"}
-        self.check_results(r, expected=expected)

=== modified file 'clickreviews/tests/test_cr_framework.py'
--- clickreviews/tests/test_cr_framework.py	2015-10-16 02:54:07 +0000
+++ clickreviews/tests/test_cr_framework.py	2016-02-10 19:30:47 +0000
@@ -19,7 +19,10 @@
 
 
 class TestClickReviewFramework(cr_tests.TestClickReview):
-    """Tests for the lint review tool."""
+    """Tests for the framework review tool."""
+    def setUp(self):
+        super().setUp()
+        self.set_test_pkgfmt("snap", "15.04")
 
     def test_framework_hook_obsolete(self):
         '''Test check_framework_hook_obsolete()'''

=== modified file 'clickreviews/tests/test_cr_lint.py'
--- clickreviews/tests/test_cr_lint.py	2016-02-01 19:07:58 +0000
+++ clickreviews/tests/test_cr_lint.py	2016-02-10 19:30:47 +0000
@@ -17,7 +17,7 @@
 from unittest import TestCase
 from unittest.mock import patch
 
-from clickreviews.cr_common import cleanup_unpack
+from clickreviews.common import cleanup_unpack
 from clickreviews.cr_lint import ClickReviewLint
 from clickreviews.cr_lint import MINIMUM_CLICK_FRAMEWORK_VERSION
 from clickreviews.frameworks import FRAMEWORKS_DATA_URL, USER_DATA_FILE
@@ -168,16 +168,6 @@
         expected_counts = {'info': 15, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_control_architecture_snappy_1604(self):
-        '''Test check_control() (architecture) - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        c = ClickReviewLint(self.test_name)
-        c.check_control()
-        r = c.click_report
-        # should be empty with this pkgfmt
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_control_architecture_missing(self):
         '''Test check_control() (architecture missing)'''
         self.set_test_control("Architecture", None)
@@ -202,7 +192,7 @@
         self.set_test_control("Architecture", "armhf")
         self.set_test_manifest("architecture", "amd64")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_control()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -213,7 +203,7 @@
         self.set_test_control("Architecture", ["all"])
         self.set_test_manifest("architecture", "all")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_control()
         r = c.click_report
         expected_counts = {'info': 15, 'warn': 0, 'error': 0}
@@ -278,16 +268,6 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_manifest_missing_arch_snappy_1604(self):
-        '''Test check_manifest_architecture() - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_manifest("architecture", None)
-        c = ClickReviewLint(self.test_name)
-        c.check_manifest_architecture()
-        r = c.click_report
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_manifest_arch_all(self):
         '''Test check_manifest_architecture() (all)'''
         self.set_test_manifest("architecture", "all")
@@ -393,7 +373,7 @@
                                         self.test_control['Version'],
                                         arch)
         c = ClickReviewLint(test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_manifest_architecture()
         r = c.click_report
         expected_counts = {'info': 0, 'warn': 0, 'error': 1}
@@ -416,7 +396,7 @@
     def test_check_control(self):
         """A very basic test to make sure check_control can be tested."""
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_control()
         r = c.click_report
         expected_counts = {'info': 15, 'warn': 0, 'error': 0}
@@ -425,7 +405,7 @@
     def test_check_control_snap(self):
         """check_control with snap."""
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_control()
         r = c.click_report
         expected_counts = {'info': 15, 'warn': 0, 'error': 0}
@@ -434,7 +414,7 @@
     def test_check_control_snap_missing_maintainer(self):
         """check_control with snap with missing maintainer."""
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         self.set_test_control('Maintainer', None)
         c.check_control()
         r = c.click_report
@@ -474,7 +454,7 @@
         '''Test check_maintainer() - empty'''
         self.set_test_manifest("maintainer", "")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -484,7 +464,7 @@
         '''Test check_maintainer() - empty (snap)'''
         self.set_test_manifest("maintainer", "")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -494,7 +474,7 @@
         '''Test check_maintainer() - missing (click)'''
         self.set_test_manifest("maintainer", None)
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': 0, 'warn': 0, 'error': 1}
@@ -504,7 +484,7 @@
         '''Test check_maintainer() - missing (snap)'''
         self.set_test_manifest("maintainer", None)
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -514,7 +494,7 @@
         '''Test check_maintainer() - badly formatted'''
         self.set_test_manifest("maintainer", "$%^@*")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -524,7 +504,7 @@
         '''Test check_maintainer() - badly formatted (snap)'''
         self.set_test_manifest("maintainer", "$%^@*")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -536,7 +516,7 @@
         self.set_test_manifest("maintainer",
                                "[e-mail]")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -548,7 +528,7 @@
         self.set_test_manifest("maintainer",
                                "[e-mail]")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_maintainer()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -585,16 +565,6 @@
         expected_counts = {'info': 3, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_icon_snappy_1604(self):
-        '''Test check_icon() - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_manifest("icon", "someicon")
-        c = ClickReviewLint(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_unspecified(self):
         '''Test check_icon()'''
         self.set_test_manifest("icon", None)
@@ -685,20 +655,6 @@
         expected_counts = {'info': 0, 'warn': 1, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_click_local_extensions_snappy_1604(self):
-        '''Testeck_click_local_extensions() - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        for k in self.test_manifest.keys():
-            if k.startswith("x-"):
-                self.set_test_manifest(k, None)
-        self.set_test_manifest("x-source", {"vcs-bzr": "lp:notes-app",
-                                            "vcs-bzr-revno": "209"})
-        c = ClickReviewLint(self.test_name)
-        c.check_click_local_extensions()
-        r = c.click_report
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_framework(self):
         '''Test check_framework()'''
         self.patch_frameworks()
@@ -715,7 +671,7 @@
         self.set_test_manifest("framework",
                                "ubuntu-sdk-14.10-qml-dev2,ubuntu-core-15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_framework()
         r = c.click_report
         expected_counts = {'info': 0, 'warn': 0, 'error': 1}
@@ -727,25 +683,12 @@
         self.set_test_manifest("framework",
                                "ubuntu-sdk-14.10-qml-dev2,ubuntu-core-15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
+        c.is_snap1 = True
         c.check_framework()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_framework_multiple_snappy_1604(self):
-        '''Test check_framework() - snappy 16.04'''
-        self.patch_frameworks()
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_manifest("framework",
-                               "ubuntu-sdk-14.10-qml-dev2,ubuntu-core-15.04")
-        c = ClickReviewLint(self.test_name)
-        c.is_snap = True
-        c.check_framework()
-        r = c.click_report
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     @patch('clickreviews.remote.read_cr_file')
     def test_check_framework_fetches_remote_data(self, mock_read_cr_file):
         '''Test check_framework()'''
@@ -839,17 +782,6 @@
         expected_counts = {'info': 5, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_hooks_snappy_1604(self):
-        '''Test check_hooks() - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_manifest("framework", "ubuntu-sdk-13.10")
-        c = ClickReviewLint(self.test_name)
-        c.check_hooks()
-        r = c.click_report
-        # this should be 0 with this pkgfmt
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_hooks_multiple_desktop_apps(self):
         '''Test check_hooks() - multiple desktop apps'''
         self.set_test_manifest("framework", "ubuntu-sdk-13.10")
@@ -979,16 +911,6 @@
         expected_counts = {'info': 3, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_hooks_unknown_nonexistent_snappy_1604(self):
-        '''Test check_hooks_unknown() - nonexistent - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_manifest("framework", "ubuntu-sdk-13.10")
-        c = ClickReviewLint(self.test_name)
-        c.check_hooks_unknown()
-        r = c.click_report
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_hooks_unknown_good(self):
         '''Test check_hooks_unknown()'''
         self.set_test_manifest("framework", "ubuntu-sdk-13.10")
@@ -1031,23 +953,13 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_hooks_redflagged_payui_snappy_1604(self):
-        '''Test check_hooks_redflagged() - pay-ui - snappy 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_manifest("framework", "ubuntu-sdk-13.10")
-        c = ClickReviewLint(self.test_name)
-        c.check_hooks_redflagged()
-        r = c.click_report
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_hooks_redflagged_apparmor_profile(self):
         '''Test check_hooks_redflagged() - apparmor-profile'''
         self.set_test_manifest("framework", "ubuntu-sdk-13.10")
         c = ClickReviewLint(self.test_name)
         c.manifest['hooks'][self.default_appname]["apparmor-profile"] = "foo"
         # snap checks are handled elsewhere
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_hooks_redflagged()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1059,7 +971,6 @@
         '''Test check_pkgname - toplevel'''
         self.set_test_manifest("name", "foo")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
         c.check_pkgname()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -1069,7 +980,7 @@
         '''Test check_pkgname - flat'''
         self.set_test_manifest("name", "foo.bar")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_pkgname()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -1079,39 +990,17 @@
         '''Test check_pkgname - reverse domain'''
         self.set_test_manifest("name", "com.ubuntu.develeper.baz.foo")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_pkgname()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_snappy_name_toplevel(self):
-        '''Test check_snappy_name - toplevel'''
-        self.set_test_pkg_yaml("name", "foo")
-        c = ClickReviewLint(self.test_name)
-        c.is_snap = True
-        c.check_snappy_name()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_snappy_name_toplevel_1504(self):
         '''Test check_snappy_name - toplevel - 15.04'''
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "foo")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
-        c.check_snappy_name()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
-    def test_snappy_name_toplevel_1604(self):
-        '''Test check_snappy_name - toplevel - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("name", "foo")
-        c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_name()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
@@ -1119,9 +1008,9 @@
 
     def test_snappy_name_flat(self):
         '''Test check_snappy_name - obsoleted flat'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "foo.bar")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_name()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1129,9 +1018,9 @@
 
     def test_snappy_name_reverse_domain(self):
         '''Test check_snappy_name - obsoleted reverse domain'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "com.ubuntu.develeper.baz.foo")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_name()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1139,6 +1028,7 @@
 
     def test_snappy_name_bad(self):
         '''Test check_snappy_name - bad'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "foo?bar")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_name()
@@ -1148,6 +1038,7 @@
 
     def test_snappy_name_bad2(self):
         '''Test check_snappy_name - empty'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_name()
@@ -1157,6 +1048,7 @@
 
     def test_snappy_name_bad3(self):
         '''Test check_snappy_name - list'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", [])
         c = ClickReviewLint(self.test_name)
         c.check_snappy_name()
@@ -1166,6 +1058,7 @@
 
     def test_snappy_name_bad4(self):
         '''Test check_snappy_name - dict'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", {})
         c = ClickReviewLint(self.test_name)
         c.check_snappy_name()
@@ -1183,18 +1076,9 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_snappy_version_1604(self):
-        '''Test check_snappy_version - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("version", 1)
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_version()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_snappy_version1(self):
         '''Test check_snappy_version - integer'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", 1)
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1204,6 +1088,7 @@
 
     def test_snappy_version2(self):
         '''Test check_snappy_version - float'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", 1.0)
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1213,6 +1098,7 @@
 
     def test_snappy_version3(self):
         '''Test check_snappy_version - MAJOR.MINOR.MICRO'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", "1.0.1")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1222,6 +1108,7 @@
 
     def test_snappy_version4(self):
         '''Test check_snappy_version - str'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", "1.0a")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1231,6 +1118,7 @@
 
     def test_snappy_version5(self):
         '''Test check_snappy_version - alpha'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", "a.b")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1240,6 +1128,7 @@
 
     def test_snappy_version_bad(self):
         '''Test check_snappy_version - bad'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", "foo?bar")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1249,6 +1138,7 @@
 
     def test_snappy_version_bad2(self):
         '''Test check_snappy_version - empty'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", "")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1258,6 +1148,7 @@
 
     def test_snappy_version_bad3(self):
         '''Test check_snappy_version - list'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", [])
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1267,6 +1158,7 @@
 
     def test_snappy_version_bad4(self):
         '''Test check_snappy_version - dict'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("version", {})
         c = ClickReviewLint(self.test_name)
         c.check_snappy_version()
@@ -1276,6 +1168,7 @@
 
     def test_snappy_type(self):
         '''Test check_snappy_type - unspecified'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("type", None)
         c = ClickReviewLint(self.test_name)
         c.check_snappy_type()
@@ -1283,15 +1176,6 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_snappy_type_app(self):
-        '''Test check_snappy_type - app'''
-        self.set_test_pkg_yaml("type", "app")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_snappy_type_app_1504(self):
         '''Test check_snappy_type - app - 15.04'''
         self.set_test_pkgfmt("snap", "15.04")
@@ -1302,18 +1186,9 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_snappy_type_app_1604(self):
-        '''Test check_snappy_type - app - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("type", "app")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_snappy_type_framework(self):
         '''Test check_snappy_type - framework'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("type", "framework")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_type()
@@ -1323,6 +1198,7 @@
 
     def test_snappy_type_oem(self):
         '''Test check_snappy_type - oem'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("type", "oem")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_type()
@@ -1330,42 +1206,6 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_snappy_type_gadget(self):
-        '''Test check_snappy_type - gadget'''
-        self.set_test_pkg_yaml("type", "gadget")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
-    def test_snappy_type_os(self):
-        '''Test check_snappy_type - os'''
-        self.set_test_pkg_yaml("type", "os")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
-    def test_snappy_type_kernel(self):
-        '''Test check_snappy_type - kernel'''
-        self.set_test_pkg_yaml("type", "kernel")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
-    def test_snappy_type_redflagged(self):
-        '''Test check_snappy_type_redflagged - unspecified'''
-        self.set_test_pkg_yaml("type", None)
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type_redflagged()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_snappy_type_redflagged_1504(self):
         '''Test check_snappy_type_redflagged - unspecified - 15.04'''
         self.set_test_pkgfmt("snap", "15.04")
@@ -1376,18 +1216,9 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_snappy_type_redflagged_1604(self):
-        '''Test check_snappy_type_redflagged - unspecified - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("type", None)
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type_redflagged()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_snappy_type_redflagged_app(self):
         '''Test check_snappy_type_redflagged - app'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("type", "app")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_type_redflagged()
@@ -1397,6 +1228,7 @@
 
     def test_snappy_type_redflagged_framework(self):
         '''Test check_snappy_type_redflagged - framework'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("type", "framework")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_type_redflagged()
@@ -1406,6 +1238,7 @@
 
     def test_snappy_type_redflagged_oem(self):
         '''Test check_snappy_type_redflagged - oem'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("type", "oem")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_type_redflagged()
@@ -1413,42 +1246,6 @@
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
         self.check_results(r, expected_counts)
 
-    def test_snappy_type_redflagged_gadget(self):
-        '''Test check_snappy_type_redflagged - gadget'''
-        self.set_test_pkg_yaml("type", "gadget")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type_redflagged()
-        r = c.click_report
-        expected_counts = {'info': None, 'warn': 0, 'error': 1}
-        self.check_results(r, expected_counts)
-
-    def test_snappy_type_redflagged_os(self):
-        '''Test check_snappy_type_redflagged - os'''
-        self.set_test_pkg_yaml("type", "os")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type_redflagged()
-        r = c.click_report
-        expected_counts = {'info': None, 'warn': 0, 'error': 1}
-        self.check_results(r, expected_counts)
-
-    def test_snappy_type_redflagged_kernel(self):
-        '''Test check_snappy_type_redflagged - kernel'''
-        self.set_test_pkg_yaml("type", "kernel")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_type_redflagged()
-        r = c.click_report
-        expected_counts = {'info': None, 'warn': 0, 'error': 1}
-        self.check_results(r, expected_counts)
-
-    def test_check_snappy_icon(self):
-        '''Test check_snappy_icon()'''
-        self.set_test_pkg_yaml("icon", "someicon")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_icon()
-        r = c.click_report
-        expected_counts = {'info': 3, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_snappy_icon_1504(self):
         '''Test check_snappy_icon() - 15.04'''
         self.set_test_pkgfmt("snap", "15.04")
@@ -1459,18 +1256,9 @@
         expected_counts = {'info': 3, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_snappy_icon_1604(self):
-        '''Test check_snappy_icon() - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("icon", "someicon")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_icon()
-        r = c.click_report
-        expected_counts = {'info': 3, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_snappy_icon_unspecified(self):
         '''Test check_snappy_icon() - unspecified'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("icon", None)
         c = ClickReviewLint(self.test_name)
         c.check_snappy_icon()
@@ -1480,6 +1268,7 @@
 
     def test_check_snappy_icon_empty(self):
         '''Test check_snappy_icon() - empty'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("icon", "")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_icon()
@@ -1489,6 +1278,7 @@
 
     def test_check_snappy_icon_absolute_path(self):
         '''Test check_snappy_icon() - absolute path'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("icon", "/foo/bar/someicon")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_icon()
@@ -1501,18 +1291,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", None)
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
-        c.check_snappy_architecture()
-        r = c.click_report
-        expected_counts = {'info': 2, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
-    def test_check_snappy_missing_arch_1604(self):
-        '''Test check_snappy_architecture() (missing)'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("architectures", None)
-        c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1523,7 +1301,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architecture", "all")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 1, 'error': 0}
@@ -1534,7 +1311,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architecture", "amd64")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 1, 'warn': 1, 'error': 0}
@@ -1545,7 +1321,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", ["all"])
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1556,7 +1331,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", ["armhf"])
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1567,7 +1341,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", ["arm64"])
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1578,7 +1351,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", ["i386"])
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1589,7 +1361,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", ["amd64"])
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1600,7 +1371,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", ["nonexistent"])
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1611,7 +1381,6 @@
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("architectures", "multi")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1625,7 +1394,6 @@
                                        self.test_control['Version'],
                                        "armhf")
         c = ClickReviewLint(test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1640,7 +1408,6 @@
                                        self.test_control['Version'],
                                        arch)
         c = ClickReviewLint(test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1655,7 +1422,6 @@
                                        self.test_control['Version'],
                                        arch)
         c = ClickReviewLint(test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1670,7 +1436,6 @@
                                        self.test_control['Version'],
                                        arch)
         c = ClickReviewLint(test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
@@ -1685,7 +1450,6 @@
                                        self.test_control['Version'],
                                        arch)
         c = ClickReviewLint(test_name)
-        c.is_snap = True
         c.check_snappy_architecture()
         r = c.click_report
         expected_counts = {'info': None, 'warn': 0, 'error': 1}
@@ -1693,15 +1457,6 @@
 
     def test_check_snappy_unknown_entries(self):
         '''Test check_snappy_unknown_entries - none'''
-        self.set_test_pkg_yaml("name", "foo")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_unknown_entries()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
-    def test_check_snappy_unknown_entries_1504(self):
-        '''Test check_snappy_unknown_entries - none - 15.04'''
         self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "foo")
         c = ClickReviewLint(self.test_name)
@@ -1710,18 +1465,9 @@
         expected_counts = {'info': 1, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_snappy_unknown_entries_1604(self):
-        '''Test check_snappy_unknown_entries - none - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        self.set_test_pkg_yaml("name", "foo")
-        c = ClickReviewLint(self.test_name)
-        c.check_snappy_unknown_entries()
-        r = c.click_report
-        expected_counts = {'info': 1, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_snappy_unknown_entries2(self):
         '''Test check_snappy_unknown_entries - one'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("nonexistent", "bar")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_unknown_entries()
@@ -1731,6 +1477,7 @@
 
     def test_check_snappy_unknown_obsoleted(self):
         '''Test check_snappy_unknown_entries - obsoleted'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("maintainer", "bar")
         c = ClickReviewLint(self.test_name)
         c.check_snappy_unknown_entries()
@@ -1745,6 +1492,7 @@
 
     def test_check_snappy_readme_md(self):
         '''Test check_snappy_readme_md()'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_readme_md("%s - some description" %
                                 self.test_name.split('_')[0])
@@ -1754,23 +1502,9 @@
         expected_counts = {'info': 2, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_snappy_readme_md_squashfs(self):
-        '''Test check_snappy_readme_md() - squashfs file'''
-        with patch("clickreviews.cr_lint.is_squashfs") as mock_is_squashfs:
-            mock_is_squashfs.return_value = True
-            with patch("clickreviews.cr_lint.ClickReviewLint."
-                       "_extract_readme_md") as mock_readme_md:
-                mock_readme_md.return_value = "Something suitably long"
-                c = ClickReviewLint(self.test_name)
-                c.unpack_dir = "/nonexistent.nonexec"
-                c.check_snappy_readme_md()
-                r = c.click_report
-                expected_counts = {'info': None, 'warn': 0, 'error': 0}
-                self.check_results(r, expected_counts)
-                self.assertFalse(mock_readme_md.called)
-
     def test_check_snappy_readme_md_bad(self):
         '''Test check_snappy_readme_md() - short'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", "prettylong.name")
         self.set_test_readme_md("abc")
         c = ClickReviewLint(self.test_name)
@@ -1781,6 +1515,7 @@
 
     def test_check_snappy_readme_md_bad2(self):
         '''Test check_snappy_readme_md() - missing'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_readme_md(None)
         c = ClickReviewLint(self.test_name)
@@ -1791,6 +1526,7 @@
 
     def test_check_snappy_services_and_binaries1(self):
         '''Test check_snappy_services_and_binaries() - different'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_pkg_yaml("services", [{"name": "foo",
                                              "start": "bin/foo"}])
@@ -1803,6 +1539,7 @@
 
     def test_check_snappy_services_and_binaries2(self):
         '''Test check_snappy_services_and_binaries() - different (exec)'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_pkg_yaml("services", [{"name": "foo",
                                              "start": "bin/foo"}])
@@ -1816,6 +1553,7 @@
 
     def test_check_snappy_services_and_binaries3(self):
         '''Test check_snappy_services_and_binaries() - same'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_pkg_yaml("services", [{"name": "foo",
                                              "start": "bin/foo"}])
@@ -1835,6 +1573,7 @@
 
     def test_check_snappy_services_and_binaries4(self):
         '''Test check_snappy_services_and_binaries() - same (subdir)'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_pkg_yaml("services", [{"name": "foo",
                                              "start": "bin/foo"}])
@@ -1854,6 +1593,7 @@
 
     def test_check_snappy_services_and_binaries5(self):
         '''Test check_snappy_services_and_binaries() - same (exec, subdir)'''
+        self.set_test_pkgfmt("snap", "15.04")
         self.set_test_pkg_yaml("name", self.test_name.split('_')[0])
         self.set_test_pkg_yaml("services", [{"name": "foo",
                                              "start": "bin/foo"}])
@@ -1874,8 +1614,9 @@
 
     def test_check_snappy_hashes_click(self):
         '''Test check_snappy_hashes() - click'''
+        self.set_test_pkgfmt("click", "0.4")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = False
+        c.is_snap1 = False
         c.check_snappy_hashes()
         r = c.click_report
         # clicks don't have hashes.yaml, so should have no output
@@ -1884,8 +1625,8 @@
 
     def test_check_snappy_hashes_archive_sha512_missing(self):
         '''Test check_snappy_hashes() - archive-sha512 missing'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         c.check_snappy_hashes()
         r = c.click_report
         expected_counts = {'info': 0, 'warn': 0, 'error': 1}
@@ -1893,8 +1634,8 @@
 
     def test_check_snappy_hashes_archive_sha512_invalid(self):
         '''Test check_snappy_hashes() - archive-sha512 invalid'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         yaml['archive-sha512'] = 'deadbeef'
         self.set_test_hashes_yaml(yaml)
@@ -1908,8 +1649,8 @@
 
     def test_check_snappy_hashes_archive_files_missing(self):
         '''Test check_snappy_hashes() - files missing'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         del yaml['files']
         self.set_test_hashes_yaml(yaml)
@@ -1923,8 +1664,8 @@
 
     def test_check_snappy_hashes_archive_files_ok(self):
         '''Test check_snappy_hashes() - ok'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         c.pkg_files = self._test_pkg_files
         self.set_test_hashes_yaml(yaml)
@@ -1937,7 +1678,6 @@
         '''Test check_snappy_hashes() - 15.04'''
         self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         c.pkg_files = self._test_pkg_files
         self.set_test_hashes_yaml(yaml)
@@ -1946,24 +1686,10 @@
         expected_counts = {'info': 4, 'warn': 0, 'error': 0}
         self.check_results(r, expected_counts)
 
-    def test_check_snappy_hashes_1604(self):
-        '''Test check_snappy_hashes() - 16.04'''
-        self.set_test_pkgfmt("snap", "16.04")
-        c = ClickReviewLint(self.test_name)
-        c.is_snap = True
-        yaml = self._create_hashes_yaml()
-        c.pkg_files = self._test_pkg_files
-        self.set_test_hashes_yaml(yaml)
-        c.check_snappy_hashes()
-        r = c.click_report
-        # this should be empty with this package format
-        expected_counts = {'info': 0, 'warn': 0, 'error': 0}
-        self.check_results(r, expected_counts)
-
     def test_check_snappy_hashes_archive_files_missing_name(self):
         '''Test check_snappy_hashes() - missing name'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         del yaml['files'][0]['name']
         self.set_test_hashes_yaml(yaml)
@@ -1974,8 +1700,8 @@
 
     def test_check_snappy_hashes_archive_files_missing_mode(self):
         '''Test check_snappy_hashes() - missing mode'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         del yaml['files'][0]['mode']
         self.set_test_hashes_yaml(yaml)
@@ -1986,8 +1712,8 @@
 
     def test_check_snappy_hashes_archive_files_malformed_mode(self):
         '''Test check_snappy_hashes() - malformed mode'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         yaml['files'][0]['mode'] += 'extra'
         self.set_test_hashes_yaml(yaml)
@@ -1998,8 +1724,8 @@
 
     def test_check_snappy_hashes_archive_files_bad_mode_entry(self):
         '''Test check_snappy_hashes() - bad mode entry'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         count = 0
         orig_mode = None
@@ -2023,8 +1749,8 @@
 
     def test_check_snappy_hashes_archive_files_mode_world_write(self):
         '''Test check_snappy_hashes() - mode world write'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         count = 0
         for e in yaml['files']:
@@ -2045,8 +1771,8 @@
 
     def test_check_snappy_hashes_archive_files_mode_mismatch(self):
         '''Test check_snappy_hashes() - mode mismatch'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         count = 0
         orig_mode = None
@@ -2068,8 +1794,8 @@
 
     def test_check_snappy_hashes_archive_files_mode_bad_symlink(self):
         '''Test check_snappy_hashes() - mode bad symlink'''
+        self.set_test_pkgfmt("snap", "15.04")
         c = ClickReviewLint(self.test_name)
-        c.is_snap = True
         yaml = self._create_hashes_yaml()
         yaml['files'].append({'name': 'badlink', 'mode': 'lrwxrwxr-x'})
         self.set_test_hashes_yaml(yaml)
@@ -2083,8 +1809,8 @@
 
     def test_check_snappy_hashes_archive_files_mode_devices(self):