Merge lp:click/devel into lp:click

[Colin Watson]

Click 0.4.23: handle framework removal, x86 chroot support, and various other small fixes.

  [ Michael Vogt ]
  * Show human-readable error message when a click chroot subcommand fails
    because of existing or non-existing chroots (LP: #1296820).
  * Selectively disable logging on some tests to avoid message spam during
    the test runs.
  * When running hooks, remove hook symlinks if framework requirements are
    not met (LP: #1271944).
  * Cleanup the chroot if "click chroot create" fails (unless
    --keep-broken-chroot is used)
  * Fix sources.list generation when native_arch and target_arch are on the
    same archive server (part of LP #1319153).
  * Add "click framework list" command to list available frameworks
    (LP: #1294659).

  [ Pete Woods ]
  * Add libunity-scopes-dev package to chroot (LP: #1320786).

  [ Sergio Schvezov ]
  * click chroot creation depends on dpkg-architecture, so recommend
    dpkg-dev.

  [ Colin Watson ]
  * chroot: Handle the case where we can execute binaries for the target
    architecture directly and thus don't need a cross-compiler
    (LP: #1319153).

[Colin Watson (cjwatson)]

review: Approve

[lp:click/devel]

445. By Colin Watson on 2014-05-20

releasing package click version 0.4.23

446. By Colin Watson on 2014-05-20

chroot: Force dpkg-architecture to recalculate everything rather than
picking up values from the environment, to avoid the test suite getting
confused by environment variables exported by dpkg-buildpackage.

=== modified file 'click/chroot.py'
--- click/chroot.py	2014-03-31 11:11:26 +0000
+++ click/chroot.py	2014-05-20 13:13:48 +0000
@@ -22,6 +22,8 @@
 __all__ = [
     "ClickChroot",
     "ClickChrootException",
+    "ClickChrootAlreadyExistsException",
+    "ClickChrootDoesNotExistException",
     ]
 
 
@@ -72,6 +74,7 @@
         "libqt5svg5-dev:TARGET",
         "libqt5webkit5-dev:TARGET",
         "libqt5xmlpatterns5-dev:TARGET",
+        "libunity-scopes-dev:TARGET",
         "qt3d5-dev:TARGET",
         "qt5-default:TARGET",
         "qtbase5-dev:TARGET",
@@ -104,6 +107,17 @@
 
 
 class ClickChrootException(Exception):
+    """A generic issue with the chroot"""
+    pass
+
+
+class ClickChrootAlreadyExistsException(ClickChrootException):
+    """The chroot already exists"""
+    pass
+
+
+class ClickChrootDoesNotExistException(ClickChrootException):
+    """A chroot with that name does not exist yet"""
     pass
 
 
@@ -118,9 +132,10 @@
             series = framework_series[self.framework_base]
         self.series = series
         self.session = session
-        self.native_arch = subprocess.check_output(
+        system_arch = subprocess.check_output(
             ["dpkg", "--print-architecture"],
             universal_newlines=True).strip()
+        self.native_arch = self._get_native_arch(system_arch, self.target_arch)
         self.chroots_dir = "/var/lib/schroot/chroots"
         # this doesn't work because we are running this under sudo
         if 'DEBOOTSTRAP_MIRROR' in os.environ:
@@ -135,11 +150,35 @@
             self.user = pwd.getpwuid(os.getuid()).pw_name
         self.dpkg_architecture = self._dpkg_architecture()
 
+    def _get_native_arch(self, system_arch, target_arch):
+        """Determine the proper native architecture for a chroot.
+
+        Some combinations of system and target architecture do not require
+        cross-building, so in these cases we just create a chroot suitable
+        for native building.
+        """
+        if (system_arch, target_arch) in (
+                ("amd64", "i386"),
+                # This will only work if the system is running a 64-bit
+                # kernel; but there's no alternative since no i386-to-amd64
+                # cross-compiler is available in the Ubuntu archive.
+                ("i386", "amd64"),
+                ):
+            return target_arch
+        else:
+            return system_arch
+
     def _dpkg_architecture(self):
         dpkg_architecture = {}
         command = ["dpkg-architecture", "-a%s" % self.target_arch]
         env = dict(os.environ)
         env["CC"] = "true"
+        # Force dpkg-architecture to recalculate everything rather than
+        # picking up values from the environment, which will be present when
+        # running the test suite under dpkg-buildpackage.
+        for key in list(env):
+            if key.startswith("DEB_BUILD_") or key.startswith("DEB_HOST_"):
+                del env[key]
         lines = subprocess.check_output(
             command, env=env, universal_newlines=True).splitlines()
         for line in lines:
@@ -156,18 +195,23 @@
         for pocket in ['updates', 'security']:
             pockets.append('%s-%s' % (series, pocket))
         sources = []
-        if target_arch not in primary_arches:
-            for pocket in pockets:
-                sources.append("deb [arch=%s] %s %s %s" %
-                               (target_arch, ports_mirror, pocket, components))
-                sources.append("deb-src %s %s %s" %
-                               (ports_mirror, pocket, components))
-        if native_arch in primary_arches:
-            for pocket in pockets:
-                sources.append("deb [arch=%s] %s %s %s" %
-                               (native_arch, self.archive, pocket, components))
-                sources.append("deb-src %s %s %s" %
-                               (self.archive, pocket, components))
+        # write binary lines
+        arches = [target_arch]
+        if native_arch != target_arch:
+            arches.append(native_arch)
+        for arch in arches:
+            if arch not in primary_arches:
+                mirror = ports_mirror
+            else:
+                mirror = self.archive
+            for pocket in pockets:
+                sources.append("deb [arch=%s] %s %s %s" %
+                               (arch, mirror, pocket, components))
+        # write source lines
+        for pocket in pockets:
+            sources.append("deb-src %s %s %s" %
+                           (self.archive, pocket, components))
+
         return sources
 
     @property
@@ -195,9 +239,16 @@
         mode = stat.S_IMODE(os.stat(path).st_mode)
         os.chmod(path, mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
 
-    def create(self):
+    def _make_cross_package(self, prefix):
+        if self.native_arch == self.target_arch:
+            return prefix
+        else:
+            target_tuple = self.dpkg_architecture["DEB_HOST_GNU_TYPE"]
+            return "%s-%s" % (prefix, target_tuple)
+
+    def create(self, keep_broken_chroot_on_fail=False):
         if self.exists():
-            raise ClickChrootException(
+            raise ClickChrootAlreadyExistsException(
                 "Chroot %s already exists" % self.full_name)
         components = ["main", "restricted", "universe", "multiverse"]
         mount = "%s/%s" % (self.chroots_dir, self.full_name)
@@ -208,11 +259,10 @@
             proxy = subprocess.check_output(
                 'unset x; eval "$(apt-config shell x Acquire::HTTP::Proxy)"; echo "$x"',
                 shell=True, universal_newlines=True).strip()
-        target_tuple = self.dpkg_architecture["DEB_HOST_GNU_TYPE"]
         build_pkgs = [
             "build-essential", "fakeroot",
-            "apt-utils", "g++-%s" % target_tuple,
-            "pkg-config-%s" % target_tuple, "cmake",
+            "apt-utils", self._make_cross_package("g++"),
+            self._make_cross_package("pkg-config"), "cmake",
             "dpkg-cross", "libc-dev:%s" % self.target_arch
             ]
         for package in extra_packages.get(self.framework_base, []):
@@ -312,11 +362,18 @@
             print("apt-get clean", file=finish)
         self._make_executable(finish_script)
         command = ["/finish.sh"]
-        return self.maint(*command)
+        ret_code = self.maint(*command)
+        if ret_code != 0 and not keep_broken_chroot_on_fail:
+            # cleanup on failure
+            self.destroy()
+            raise ClickChrootException(
+                "Failed to create chroot '{}' (exit status {})".format(
+                    self.full_name, ret_code))
+        return ret_code
 
     def run(self, *args):
         if not self.exists():
-            raise ClickChrootException(
+            raise ClickChrootDoesNotExistException(
                 "Chroot %s does not exist" % self.full_name)
         command = ["schroot", "-c"]
         if self.session:
@@ -353,7 +410,7 @@
 
     def install(self, *pkgs):
         if not self.exists():
-            raise ClickChrootException(
+            raise ClickChrootDoesNotExistException(
                 "Chroot %s does not exist" % self.full_name)
         ret = self.update()
         if ret != 0:
@@ -375,7 +432,7 @@
 
     def upgrade(self):
         if not self.exists():
-            raise ClickChrootException(
+            raise ClickChrootDoesNotExistException(
                 "Chroot %s does not exist" % self.full_name)
         ret = self.update()
         if ret != 0:
@@ -388,7 +445,7 @@
 
     def destroy(self):
         if not self.exists():
-            raise ClickChrootException(
+            raise ClickChrootDoesNotExistException(
                 "Chroot %s does not exist" % self.full_name)
         chroot_config = "/etc/schroot/chroot.d/%s" % self.full_name
         os.remove(chroot_config)
@@ -398,7 +455,7 @@
 
     def begin_session(self):
         if not self.exists():
-            raise ClickChrootException(
+            raise ClickChrootDoesNotExistException(
                 "Chroot %s does not exist" % self.full_name)
         command = ["schroot", "-c", self.full_name, "--begin-session",
                    "--session-name", self.full_session_name]
@@ -407,7 +464,7 @@
 
     def end_session(self):
         if not self.exists():
-            raise ClickChrootException(
+            raise ClickChrootDoesNotExistException(
                 "Chroot %s does not exist" % self.full_name)
         command = ["schroot", "-c", self.full_session_name, "--end-session"]
         subprocess.check_call(command)

=== modified file 'click/commands/__init__.py'
--- click/commands/__init__.py	2013-10-31 20:17:19 +0000
+++ click/commands/__init__.py	2014-05-20 13:13:48 +0000
@@ -24,6 +24,7 @@
     "chroot",
     "contents",
     "desktophook",
+    "framework",
     "hook",
     "info",
     "install",

=== modified file 'click/commands/chroot.py'
--- click/commands/chroot.py	2014-03-31 11:11:26 +0000
+++ click/commands/chroot.py	2014-05-20 13:13:48 +0000
@@ -20,9 +20,14 @@
 from __future__ import print_function
 
 from argparse import ArgumentParser, REMAINDER
+from contextlib import contextmanager
 import os
 
-from click.chroot import ClickChroot
+from click.chroot import (
+    ClickChroot,
+    ClickChrootAlreadyExistsException,
+    ClickChrootDoesNotExistException,
+)
 from click import osextras
 
 
@@ -31,6 +36,25 @@
         parser.error("must be run as root; try sudo")
 
 
+@contextmanager
+def message_on_error(exc, msg):
+    """
+    Context Manager that prints the error message 'msg' on exception 'exc'
+    """
+    try:
+        yield
+    except exc:
+        print(msg)
+
+
+# FIXME: i18n(?)
+class ErrorMessages:
+    EXISTS = """A chroot for that name and architecture already exists.
+Please see the man-page how to use it."""
+    NOT_EXISTS = """A chroot for that name and architecture does not exist.
+Please use 'create' to create it."""
+
+
 def create(parser, args):
     if not osextras.find_on_path("debootstrap"):
         parser.error(
@@ -38,20 +62,32 @@
             "debootstrap")
     requires_root(parser)
     chroot = ClickChroot(args.architecture, args.framework, series=args.series)
-    return chroot.create()
+    with message_on_error(
+            ClickChrootAlreadyExistsException, ErrorMessages.EXISTS):
+        return chroot.create(args.keep_broken_chroot)
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def install(parser, args):
     packages = args.packages
     chroot = ClickChroot(args.architecture, args.framework)
-    return chroot.install(*packages)
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.install(*packages)
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def destroy(parser, args):
     requires_root(parser)
     # ask for confirmation?
     chroot = ClickChroot(args.architecture, args.framework)
-    return chroot.destroy()
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.destroy()
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def execute(parser, args):
@@ -60,7 +96,11 @@
         program = ["/bin/bash"]
     chroot = ClickChroot(
         args.architecture, args.framework, session=args.session)
-    return chroot.run(*program)
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.run(*program)
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def maint(parser, args):
@@ -69,24 +109,40 @@
         program = ["/bin/bash"]
     chroot = ClickChroot(
         args.architecture, args.framework, session=args.session)
-    return chroot.maint(*program)
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.maint(*program)
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def upgrade(parser, args):
     chroot = ClickChroot(args.architecture, args.framework)
-    return chroot.upgrade()
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.upgrade()
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def begin_session(parser, args):
     chroot = ClickChroot(
         args.architecture, args.framework, session=args.session)
-    return chroot.begin_session()
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.begin_session()
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def end_session(parser, args):
     chroot = ClickChroot(
         args.architecture, args.framework, session=args.session)
-    return chroot.end_session()
+    with message_on_error(
+            ClickChrootDoesNotExistException, ErrorMessages.NOT_EXISTS):
+        return chroot.end_session()
+    # if we reach this point there was a error so return exit_status 1
+    return 1
 
 
 def run(argv):
@@ -107,6 +163,10 @@
     create_parser = subparsers.add_parser(
         "create",
         help="create a chroot of the provided architecture")
+    create_parser.add_argument(
+        "-k", "--keep-broken-chroot", default=False, action="store_true",
+        help="Keep the chroot even if creating it fails (default is to delete "
+              "it)")
     create_parser.set_defaults(func=create)
     destroy_parser = subparsers.add_parser(
         "destroy",

=== added file 'click/commands/framework.py'
--- click/commands/framework.py	1970-01-01 00:00:00 +0000
+++ click/commands/framework.py	2014-05-20 13:13:48 +0000
@@ -0,0 +1,42 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt <[e-mail]>
+
+# 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/>.
+
+"""List available frameworks."""
+
+from __future__ import print_function
+
+from argparse import ArgumentParser
+
+from gi.repository import Click
+
+
+def list(parser, args):
+    for framework in Click.Framework.get_frameworks():
+        print("%s" % framework.props.name)
+    return 0
+
+
+def run(argv):
+    parser = ArgumentParser("click framework")
+    subparsers = parser.add_subparsers()
+    list_parser = subparsers.add_parser(
+        "list",
+        help="list available frameworks")
+    list_parser.set_defaults(func=list)
+    args = parser.parse_args(argv)
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 1
+    return args.func(parser, args)

=== modified file 'click/tests/helpers.py'
--- click/tests/helpers.py	2014-05-08 18:18:39 +0000
+++ click/tests/helpers.py	2014-05-20 13:13:48 +0000
@@ -29,6 +29,7 @@
 
 
 import contextlib
+from functools import wraps
 import os
 import re
 import shutil
@@ -45,6 +46,19 @@
 from click.tests import gimock
 
 
+def disable_logging(func):
+    """Decorator to disable logging e.g. during a test"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        import logging
+        logging.disable(logging.CRITICAL)
+        try:
+            return func(*args, **kwargs)
+        finally:
+            logging.disable(logging.NOTSET)
+    return wrapper
+
+
 class TestCase(gimock.GIMockTestCase):
     def setUp(self):
         super(TestCase, self).setUp()
@@ -108,6 +122,14 @@
         self.assertRaisesGError(
             "click_user_error-quark", code, callableObj, *args, **kwargs)
 
+    def _setup_frameworks(self, preloads, frameworks_dir=None, frameworks=[]):
+        frameworks_dir = self._create_mock_framework_dir(frameworks_dir)
+        shutil.rmtree(frameworks_dir, ignore_errors=True)
+        for framework in frameworks:
+            self._create_mock_framework_file(framework)
+        preloads["click_get_frameworks_dir"].side_effect = (
+            lambda: self.make_string(frameworks_dir))
+
     def _create_mock_framework_dir(self, frameworks_dir=None):
         if frameworks_dir is None:
             frameworks_dir = os.path.join(self.temp_dir, "frameworks")

=== modified file 'click/tests/test_build.py'
--- click/tests/test_build.py	2014-05-05 13:10:19 +0000
+++ click/tests/test_build.py	2014-05-20 13:13:48 +0000
@@ -33,7 +33,12 @@
 
 from click.build import ClickBuildError, ClickBuilder, ClickSourceBuilder
 from click.preinst import static_preinst
-from click.tests.helpers import TestCase, mkfile, touch
+from click.tests.helpers import (
+    disable_logging,
+    mkfile,
+    TestCase,
+    touch,
+)
 
 
 # BAW 2013-04-15: Some tests require umask 022.  Use this decorator to
@@ -118,6 +123,7 @@
             ["dpkg-deb", "-f", path, name],
             universal_newlines=True).rstrip("\n")
 
+    @disable_logging
     @umask(0o22)
     def test_build(self):
         self.use_temp_dir()
@@ -199,6 +205,7 @@
         self.assertEqual(
             "foo", os.readlink(os.path.join(extract_path, "bin", "bar")))
 
+    @disable_logging
     def test_build_excludes_dot_click(self):
         self.use_temp_dir()
         scratch = os.path.join(self.temp_dir, "scratch")
@@ -218,6 +225,7 @@
         subprocess.check_call(["dpkg-deb", "-x", path, extract_path])
         self.assertEqual([], os.listdir(extract_path))
 
+    @disable_logging
     def test_build_multiple_architectures(self):
         self.use_temp_dir()
         scratch = os.path.join(self.temp_dir, "scratch")
@@ -246,6 +254,7 @@
             self.assertEqual(source_json, target_json)
 
     # FIXME: DRY violation with test_build_multiple_architectures etc
+    @disable_logging
     def test_build_multiple_frameworks(self):
         self.use_temp_dir()
         scratch = os.path.join(self.temp_dir, "scratch")

=== added file 'click/tests/test_chroot.py'
--- click/tests/test_chroot.py	1970-01-01 00:00:00 +0000
+++ click/tests/test_chroot.py	2014-05-20 13:13:48 +0000
@@ -0,0 +1,123 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Michael Vogt
+
+# 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/>.
+
+"""Unit tests for click.chroot."""
+
+from __future__ import print_function
+
+__metaclass__ = type
+__all__ = [
+    'TestClickChroot',
+    ]
+
+
+from click.tests.helpers import TestCase
+from click.chroot import (
+    ClickChroot,
+)
+
+
+class TestClickChroot(TestCase):
+    def test_get_native_arch_amd64_to_amd64(self):
+        chroot = ClickChroot("amd64", "ubuntu-sdk-14.04", series="trusty")
+        self.assertEqual("amd64", chroot._get_native_arch("amd64", "amd64"))
+
+    def test_get_native_arch_amd64_to_armhf(self):
+        chroot = ClickChroot("armhf", "ubuntu-sdk-14.04", series="trusty")
+        self.assertEqual("amd64", chroot._get_native_arch("amd64", "armhf"))
+
+    def test_get_native_arch_amd64_to_i386(self):
+        chroot = ClickChroot("i386", "ubuntu-sdk-14.04", series="trusty")
+        self.assertEqual("i386", chroot._get_native_arch("amd64", "i386"))
+
+    def test_gen_sources_archive_only(self):
+        chroot = ClickChroot("amd64", "ubuntu-sdk-13.10", series="trusty")
+        chroot.native_arch = "i386"
+        sources = chroot._generate_sources(
+            chroot.series, chroot.native_arch, chroot.target_arch,
+            "main")
+        self.assertEqual([
+            'deb [arch=amd64] http://archive.ubuntu.com/ubuntu trusty main',
+            'deb [arch=amd64] http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb [arch=amd64] http://archive.ubuntu.com/ubuntu trusty-security main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty-security main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-security main',
+        ], sources)
+
+    def test_gen_sources_mixed_archive_ports(self):
+        chroot = ClickChroot("armhf", "ubuntu-sdk-13.10", series="trusty")
+        chroot.native_arch = "i386"
+        sources = chroot._generate_sources(
+            chroot.series, chroot.native_arch, chroot.target_arch,
+            "main")
+        self.assertEqual([
+            'deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports trusty main',
+            'deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports trusty-updates main',
+            'deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports trusty-security main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty-security main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-security main',
+        ], sources)
+
+    def test_gen_sources_ports_only(self):
+        chroot = ClickChroot("armhf", "ubuntu-sdk-13.10", series="trusty")
+        chroot.native_arch = "armel"
+        sources = chroot._generate_sources(
+            chroot.series, chroot.native_arch, chroot.target_arch,
+            "main")
+        self.assertEqual([
+            'deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports trusty main',
+            'deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports trusty-updates main',
+            'deb [arch=armhf] http://ports.ubuntu.com/ubuntu-ports trusty-security main',
+            'deb [arch=armel] http://ports.ubuntu.com/ubuntu-ports trusty main',
+            'deb [arch=armel] http://ports.ubuntu.com/ubuntu-ports trusty-updates main',
+            'deb [arch=armel] http://ports.ubuntu.com/ubuntu-ports trusty-security main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-security main',
+        ], sources)
+
+    def test_gen_sources_native(self):
+        chroot = ClickChroot("i386", "ubuntu-sdk-14.04", series="trusty")
+        chroot.native_arch = "i386"
+        sources = chroot._generate_sources(
+            chroot.series, chroot.native_arch, chroot.target_arch,
+            "main")
+        self.assertEqual([
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb [arch=i386] http://archive.ubuntu.com/ubuntu trusty-security main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-updates main',
+            'deb-src http://archive.ubuntu.com/ubuntu trusty-security main',
+        ], sources)
+
+    def test_make_cross_package_native(self):
+        chroot = ClickChroot("amd64", "ubuntu-sdk-14.04", series="trusty")
+        chroot.native_arch = "amd64"
+        self.assertEqual("g++", chroot._make_cross_package("g++"))
+
+    def test_make_cross_package_cross(self):
+        chroot = ClickChroot("armhf", "ubuntu-sdk-14.04", series="trusty")
+        chroot.native_arch = "amd64"
+        self.assertEqual(
+            "g++-arm-linux-gnueabihf", chroot._make_cross_package("g++"))

=== modified file 'click/tests/test_hooks.py'
--- click/tests/test_hooks.py	2014-04-03 08:52:02 +0000
+++ click/tests/test_hooks.py	2014-05-20 13:13:48 +0000
@@ -95,6 +95,9 @@
 
 
 class TestClickHookBase(TestCase):
+
+    TEST_USER = "test-user"
+
     def setUp(self):
         super(TestClickHookBase, self).setUp()
         self.use_temp_dir()
@@ -102,11 +105,33 @@
         self.db.add(self.temp_dir)
         self.spawn_calls = []
 
+    def _make_installed_click(self, package="test-1",version="1.0",
+                              json_data={},
+                              make_current=True,
+                              all_users=False):
+        with mkfile_utf8(os.path.join(
+                self.temp_dir, package, version, ".click", "info",
+                "%s.manifest" % package)) as f:
+            json.dump(json_data, f, ensure_ascii=False)
+        if make_current:
+            os.symlink(version, os.path.join(self.temp_dir, package, "current"))
+        if all_users:
+            db = Click.User.for_all_users(self.db)
+        else:
+            db = Click.User.for_user(self.db, self.TEST_USER)
+        db.set_version(package, version)
+
+    def _make_hook_file(self, content, hookname="test"):
+        hook_file = os.path.join(self.hooks_dir, "%s.hook" % hookname)
+        with mkfile(hook_file) as f:
+            print(content, file=f)
+
     def _setup_hooks_dir(self, preloads, hooks_dir=None):
         if hooks_dir is None:
             hooks_dir = self.temp_dir
         preloads["click_get_hooks_dir"].side_effect = (
             lambda: self.make_string(hooks_dir))
+        self.hooks_dir = hooks_dir
 
     def g_spawn_sync_side_effect(self, status_map, working_directory, argv,
                                  envp, flags, child_setup, user_data,
@@ -126,13 +151,12 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print(dedent("""\
+            self._make_hook_file(dedent("""\
                     Pattern: /usr/share/test/${id}.test
                     # Comment
                     Exec: test-update
                     User: root
-                    """), file=f)
+                    """))
             hook = Click.Hook.open(self.db, "test")
             self.assertCountEqual(
                 ["pattern", "exec", "user"], hook.get_fields())
@@ -146,8 +170,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: /usr/share/test/${id}.test", file=f)
+            self._make_hook_file(
+                "Pattern: /usr/share/test/${id}.test")
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual("test", hook.get_hook_name())
 
@@ -156,9 +180,10 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: /usr/share/test/${id}.test", file=f)
-                print("Hook-Name: other", file=f)
+            self._make_hook_file(dedent("""\
+                Pattern: /usr/share/test/${id}.test
+                Hook-Name: other""")
+            )
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual("other", hook.get_hook_name())
 
@@ -167,13 +192,12 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print(dedent("""\
+            self._make_hook_file(dedent("""\
                     Pattern: /usr/share/test/${id}.test
                     # Comment
                     Exec: test-update
                     User: root
-                    """), file=f)
+            """))
             hook = Click.Hook.open(self.db, "test")
             self.assertRaisesHooksError(
                 Click.HooksError.BAD_APP_NAME, hook.get_app_id,
@@ -187,8 +211,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: /usr/share/test/${short-id}.test", file=f)
+            self._make_hook_file(
+                "Pattern: /usr/share/test/${short-id}.test")
             hook = Click.Hook.open(self.db, "test")
             # It would perhaps be better if unrecognised $-expansions raised
             # KeyError, but they don't right now.
@@ -201,9 +225,9 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: /usr/share/test/${short-id}.test", file=f)
-                print("Single-Version: yes", file=f)
+            self._make_hook_file(dedent("""\
+                Pattern: /usr/share/test/${short-id}.test
+                Single-Version: yes"""))
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual(
                 "/usr/share/test/package_app-name.test",
@@ -231,8 +255,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(
+                "Pattern: %s/${id}.test" % self.temp_dir)
             os.makedirs(
                 os.path.join(self.temp_dir, "org.example.package", "1.0"))
             hook = Click.Hook.open(self.db, "test")
@@ -251,8 +275,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: %s/${id}/" % self.temp_dir, file=f)
+            self._make_hook_file(
+                "Pattern: %s/${id}/" % self.temp_dir)
             os.makedirs(
                 os.path.join(self.temp_dir, "org.example.package", "1.0"))
             hook = Click.Hook.open(self.db, "test")
@@ -276,8 +300,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(
+                "Pattern: %s/${id}.test" % self.temp_dir)
             underlay = os.path.join(self.temp_dir, "underlay")
             overlay = os.path.join(self.temp_dir, "overlay")
             db = Click.DB()
@@ -304,8 +328,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(
+                "Pattern: %s/${id}.test" % self.temp_dir)
             symlink_path = os.path.join(
                 self.temp_dir, "org.example.package_test-app_1.0.test")
             os.symlink("old-target", symlink_path)
@@ -325,8 +349,8 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(
+                "Pattern: %s/${id}.test" % self.temp_dir)
             symlink_path = os.path.join(
                 self.temp_dir, "org.example.package_test-app_1.0.test")
             os.symlink("old-target", symlink_path)
@@ -341,28 +365,20 @@
             enter()
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
-            with mkfile(os.path.join(self.temp_dir, "hooks", "new.hook")) as f:
-                print("Pattern: %s/${id}.new" % self.temp_dir, file=f)
-            with mkfile_utf8(os.path.join(
-                    self.temp_dir, "test-1", "1.0", ".click", "info",
-                    "test-1.manifest")) as f:
-                json.dump({
+            self._make_hook_file(
+                "Pattern: %s/${id}.new" % self.temp_dir,
+                hookname="new")
+            self._make_installed_click("test-1", "1.0", json_data={
                     "maintainer":
                         b"Unic\xc3\xb3de <[e-mail]>".decode(
                             "UTF-8"),
-                    "hooks": {"test1-app": {"new": "target-1"}},
-                }, f, ensure_ascii=False)
-            os.symlink("1.0", os.path.join(self.temp_dir, "test-1", "current"))
-            with mkfile_utf8(os.path.join(
-                    self.temp_dir, "test-2", "2.0", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({
+                    "hooks": {"test1-app": {"new": "target-1"}}})
+            self._make_installed_click("test-2", "2.0", json_data={
                     "maintainer":
                         b"Unic\xc3\xb3de <[e-mail]>".decode(
                             "UTF-8"),
                     "hooks": {"test1-app": {"new": "target-2"}},
-                }, f, ensure_ascii=False)
-            os.symlink("2.0", os.path.join(self.temp_dir, "test-2", "current"))
+                })
             hook = Click.Hook.open(self.db, "new")
             hook.install(user_name=None)
             path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.new")
@@ -382,22 +398,17 @@
             enter()
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
-            with mkfile(os.path.join(self.temp_dir, "hooks", "old.hook")) as f:
-                print("Pattern: %s/${id}.old" % self.temp_dir, file=f)
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-1", "1.0", ".click", "info",
-                    "test-1.manifest")) as f:
-                json.dump({"hooks": {"test1-app": {"old": "target-1"}}}, f)
-            os.symlink("1.0", os.path.join(self.temp_dir, "test-1", "current"))
+            self._make_hook_file(
+                "Pattern: %s/${id}.old" % self.temp_dir,
+                hookname="old")
+            self._make_installed_click("test-1", "1.0", json_data={
+                "hooks": {"test1-app": {"old": "target-1"}}})
             path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.old")
             os.symlink(
                 os.path.join(self.temp_dir, "test-1", "1.0", "target-1"),
                 path_1)
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-2", "2.0", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({"hooks": {"test2-app": {"old": "target-2"}}}, f)
-            os.symlink("2.0", os.path.join(self.temp_dir, "test-2", "current"))
+            self._make_installed_click("test-2", "2.0", json_data={
+                "hooks": {"test2-app": {"old": "target-2"}}})
             path_2 = os.path.join(self.temp_dir, "test-2_test2-app_2.0.old")
             os.symlink(
                 os.path.join(self.temp_dir, "test-2", "2.0", "target-2"),
@@ -413,23 +424,14 @@
             enter()
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
-            with mkfile(os.path.join(
-                    self.temp_dir, "hooks", "test.hook")) as f:
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-1", "1.0", ".click", "info",
-                    "test-1.manifest")) as f:
-                json.dump({"hooks": {"test1-app": {"test": "target-1"}}}, f)
-            os.symlink("1.0", os.path.join(self.temp_dir, "test-1", "current"))
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-2", "1.0", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({"hooks": {"test2-app": {"test": "target-2"}}}, f)
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-2", "1.1", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({"hooks": {"test2-app": {"test": "target-2"}}}, f)
-            os.symlink("1.1", os.path.join(self.temp_dir, "test-2", "current"))
+            self._make_hook_file(
+                "Pattern: %s/${id}.test" % self.temp_dir)
+            self._make_installed_click("test-1", "1.0", json_data={
+                "hooks": {"test1-app": {"test": "target-1"}}})
+            self._make_installed_click("test-2", "1.0", make_current=False,
+                json_data={"hooks": {"test2-app": {"test": "target-2"}}})
+            self._make_installed_click("test-2", "1.1", json_data={
+                "hooks": {"test2-app": {"test": "target-2"}}})
             path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.test")
             os.symlink(
                 os.path.join(self.temp_dir, "test-1", "1.0", "target-1"),
@@ -465,13 +467,12 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print(dedent("""\
+            self._make_hook_file(dedent("""\
                     User-Level: yes
                     Pattern: ${home}/.local/share/test/${id}.test
                     # Comment
                     Exec: test-update
-                    """), file=f)
+                    """))
             hook = Click.Hook.open(self.db, "test")
             self.assertCountEqual(
                 ["user-level", "pattern", "exec"], hook.get_fields())
@@ -486,9 +487,10 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: ${home}/.local/share/test/${id}.test", file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: ${home}/.local/share/test/${id}.test""")
+            )
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual("test", hook.get_hook_name())
 
@@ -497,10 +499,11 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: ${home}/.local/share/test/${id}.test", file=f)
-                print("Hook-Name: other", file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: ${home}/.local/share/test/${id}.test
+                Hook-Name: other""")
+            )
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual("other", hook.get_hook_name())
 
@@ -509,13 +512,12 @@
                 "click_get_hooks_dir") as (enter, preloads):
             enter()
             self._setup_hooks_dir(preloads)
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print(dedent("""\
+            self._make_hook_file(dedent("""\
                     User-Level: yes
                     Pattern: ${home}/.local/share/test/${id}.test
                     # Comment
-                    Exec: test-update
-                    """), file=f)
+                    Exec: test-update""")
+            )
             hook = Click.Hook.open(self.db, "test")
             self.assertRaisesHooksError(
                 Click.HooksError.BAD_APP_NAME, hook.get_app_id,
@@ -531,11 +533,10 @@
             self._setup_hooks_dir(preloads)
             preloads["getpwnam"].side_effect = (
                 lambda name: self.make_pointer(Passwd(pw_dir=b"/mock")))
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print(
-                    "Pattern: ${home}/.local/share/test/${short-id}.test",
-                    file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: ${home}/.local/share/test/${short-id}.test
+            """))
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual(
                 "/mock/.local/share/test/package_app-name.test",
@@ -554,8 +555,8 @@
                 print("Exec: test-update", file=f)
             hook = Click.Hook.open(self.db, "test")
             self.assertEqual(
-                "test-user", hook.get_run_commands_user(user_name="test-user"))
-            hook.run_commands(user_name="test-user")
+                self.TEST_USER, hook.get_run_commands_user(user_name=self.TEST_USER))
+            hook.run_commands(user_name=self.TEST_USER)
             self.assertEqual(
                 [[b"/bin/sh", b"-c", b"test-update"]], self.spawn_calls)
 
@@ -568,19 +569,20 @@
             preloads["click_get_user_home"].return_value = "/home/test-user"
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.0"))
-            user_db = Click.User.for_user(self.db, "test-user")
+            user_db = Click.User.for_user(self.db, self.TEST_USER)
             user_db.set_version("org.example.package", "1.0")
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: %s/${id}.test""") % self.temp_dir
+            )
             hook = Click.Hook.open(self.db, "test")
             hook.install_package(
                 "org.example.package", "1.0", "test-app", "foo/bar",
-                user_name="test-user")
+                user_name=self.TEST_USER)
             symlink_path = os.path.join(
                 self.temp_dir, "org.example.package_test-app_1.0.test")
             target_path = os.path.join(
-                self.temp_dir, ".click", "users", "test-user",
+                self.temp_dir, ".click", "users", self.TEST_USER,
                 "org.example.package", "foo", "bar")
             self.assertTrue(os.path.islink(symlink_path))
             self.assertEqual(target_path, os.readlink(symlink_path))
@@ -594,19 +596,20 @@
             preloads["click_get_user_home"].return_value = "/home/test-user"
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.0"))
-            user_db = Click.User.for_user(self.db, "test-user")
+            user_db = Click.User.for_user(self.db, self.TEST_USER)
             user_db.set_version("org.example.package", "1.0")
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: %s/${id}/" % self.temp_dir, file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: %s/${id}/""") % self.temp_dir
+            )
             hook = Click.Hook.open(self.db, "test")
             hook.install_package(
                 "org.example.package", "1.0", "test-app", "foo",
-                user_name="test-user")
+                user_name=self.TEST_USER)
             symlink_path = os.path.join(
                 self.temp_dir, "org.example.package_test-app_1.0")
             target_path = os.path.join(
-                self.temp_dir, ".click", "users", "test-user",
+                self.temp_dir, ".click", "users", self.TEST_USER,
                 "org.example.package", "foo")
             self.assertTrue(os.path.islink(symlink_path))
             self.assertEqual(target_path, os.readlink(symlink_path))
@@ -622,18 +625,19 @@
                 self.temp_dir, "org.example.package", "1.0"))
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.1"))
-            user_db = Click.User.for_user(self.db, "test-user")
+            user_db = Click.User.for_user(self.db, self.TEST_USER)
             user_db.set_version("org.example.package", "1.0")
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: %s/${id}.test""") % self.temp_dir
+            )
             hook = Click.Hook.open(self.db, "test")
             hook.install_package(
                 "org.example.package", "1.0", "test-app", "foo/bar",
-                user_name="test-user")
+                user_name=self.TEST_USER)
             hook.install_package(
                 "org.example.package", "1.1", "test-app", "foo/bar",
-                user_name="test-user")
+                user_name=self.TEST_USER)
             old_symlink_path = os.path.join(
                 self.temp_dir, "org.example.package_test-app_1.0.test")
             symlink_path = os.path.join(
@@ -641,7 +645,7 @@
             self.assertFalse(os.path.islink(old_symlink_path))
             self.assertTrue(os.path.islink(symlink_path))
             target_path = os.path.join(
-                self.temp_dir, ".click", "users", "test-user",
+                self.temp_dir, ".click", "users", self.TEST_USER,
                 "org.example.package", "foo", "bar")
             self.assertEqual(target_path, os.readlink(symlink_path))
 
@@ -657,17 +661,18 @@
             os.symlink("old-target", symlink_path)
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.0"))
-            user_db = Click.User.for_user(self.db, "test-user")
+            user_db = Click.User.for_user(self.db, self.TEST_USER)
             user_db.set_version("org.example.package", "1.0")
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: %s/${id}.test""") % self.temp_dir
+            )
             hook = Click.Hook.open(self.db, "test")
             hook.install_package(
                 "org.example.package", "1.0", "test-app", "foo/bar",
-                user_name="test-user")
+                user_name=self.TEST_USER)
             target_path = os.path.join(
-                self.temp_dir, ".click", "users", "test-user",
+                self.temp_dir, ".click", "users", self.TEST_USER,
                 "org.example.package", "foo", "bar")
             self.assertTrue(os.path.islink(symlink_path))
             self.assertEqual(target_path, os.readlink(symlink_path))
@@ -679,16 +684,17 @@
             enter()
             self._setup_hooks_dir(preloads)
             preloads["click_get_user_home"].return_value = "/home/test-user"
-            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-                print("User-Level: yes", file=f)
-                print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
+            self._make_hook_file(dedent("""\
+                User-Level: yes
+                Pattern: %s/${id}.test""") % self.temp_dir
+            )
             symlink_path = os.path.join(
                 self.temp_dir, "org.example.package_test-app_1.0.test")
             os.symlink("old-target", symlink_path)
             hook = Click.Hook.open(self.db, "test")
             hook.remove_package(
                 "org.example.package", "1.0", "test-app",
-                user_name="test-user")
+                user_name=self.TEST_USER)
             self.assertFalse(os.path.exists(symlink_path))
 
     def test_install(self):
@@ -696,32 +702,26 @@
                 "click_get_hooks_dir", "click_get_user_home",
                 ) as (enter, preloads):
             enter()
+            # Don't tell click about the hooks directory yet.
             self._setup_hooks_dir(preloads)
             preloads["click_get_user_home"].return_value = "/home/test-user"
             with mkfile(os.path.join(self.temp_dir, "hooks", "new.hook")) as f:
                 print("User-Level: yes", file=f)
                 print("Pattern: %s/${id}.new" % self.temp_dir, file=f)
-            user_db = Click.User.for_user(self.db, "test-user")
-            with mkfile_utf8(os.path.join(
-                    self.temp_dir, "test-1", "1.0", ".click", "info",
-                    "test-1.manifest")) as f:
-                json.dump({
+            self._make_installed_click("test-1", "1.0", json_data={
                     "maintainer":
                         b"Unic\xc3\xb3de <[e-mail]>".decode(
                             "UTF-8"),
                     "hooks": {"test1-app": {"new": "target-1"}},
-                }, f, ensure_ascii=False)
-            user_db.set_version("test-1", "1.0")
-            with mkfile_utf8(os.path.join(
-                    self.temp_dir, "test-2", "2.0", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({
+            })
+            self._make_installed_click("test-2", "2.0", json_data={
                     "maintainer":
                         b"Unic\xc3\xb3de <[e-mail]>".decode(
                             "UTF-8"),
                     "hooks": {"test1-app": {"new": "target-2"}},
-                }, f, ensure_ascii=False)
-            user_db.set_version("test-2", "2.0")
+                })
+            # Now tell click about the hooks directory and make sure it
+            # catches up correctly.
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
             hook = Click.Hook.open(self.db, "new")
@@ -730,14 +730,14 @@
             self.assertTrue(os.path.lexists(path_1))
             self.assertEqual(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-1",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-1",
                     "target-1"),
                 os.readlink(path_1))
             path_2 = os.path.join(self.temp_dir, "test-2_test1-app_2.0.new")
             self.assertTrue(os.path.lexists(path_2))
             self.assertEqual(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-2",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-2",
                     "target-2"),
                 os.readlink(path_2))
 
@@ -747,17 +747,17 @@
             self.assertFalse(os.path.lexists(path_1))
             self.assertFalse(os.path.lexists(path_2))
 
-            hook.install(user_name="test-user")
+            hook.install(user_name=self.TEST_USER)
             self.assertTrue(os.path.lexists(path_1))
             self.assertEqual(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-1",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-1",
                     "target-1"),
                 os.readlink(path_1))
             self.assertTrue(os.path.lexists(path_2))
             self.assertEqual(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-2",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-2",
                     "target-2"),
                 os.readlink(path_2))
 
@@ -766,29 +766,25 @@
                 "click_get_hooks_dir", "click_get_user_home",
                 ) as (enter, preloads):
             enter()
+            # Don't tell click about the hooks directory yet.
             self._setup_hooks_dir(preloads)
             preloads["click_get_user_home"].return_value = "/home/test-user"
             with mkfile(os.path.join(self.temp_dir, "hooks", "old.hook")) as f:
                 print("User-Level: yes", file=f)
                 print("Pattern: %s/${id}.old" % self.temp_dir, file=f)
-            user_db = Click.User.for_user(self.db, "test-user")
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-1", "1.0", ".click", "info",
-                    "test-1.manifest")) as f:
-                json.dump({"hooks": {"test1-app": {"old": "target-1"}}}, f)
-            user_db.set_version("test-1", "1.0")
-            os.symlink("1.0", os.path.join(self.temp_dir, "test-1", "current"))
+            user_db = Click.User.for_user(self.db, self.TEST_USER)
+            self._make_installed_click("test-1", "1.0", json_data={
+                "hooks": {"test1-app": {"old": "target-1"}}})
             path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.old")
             os.symlink(
                 os.path.join(user_db.get_path("test-1"), "target-1"), path_1)
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-2", "2.0", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({"hooks": {"test2-app": {"old": "target-2"}}}, f)
-            user_db.set_version("test-2", "2.0")
+            self._make_installed_click("test-2", "2.0", json_data={
+                "hooks": {"test2-app": {"old": "target-2"}}})
             path_2 = os.path.join(self.temp_dir, "test-2_test2-app_2.0.old")
             os.symlink(
                 os.path.join(user_db.get_path("test-2"), "target-2"), path_2)
+            # Now tell click about the hooks directory and make sure it
+            # catches up correctly.
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
             hook = Click.Hook.open(self.db, "old")
@@ -807,44 +803,37 @@
                     os.path.join(self.temp_dir, "hooks", "test.hook")) as f:
                 print("User-Level: yes", file=f)
                 print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-            user_db = Click.User.for_user(self.db, "test-user")
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-1", "1.0", ".click", "info",
-                    "test-1.manifest")) as f:
-                json.dump({"hooks": {"test1-app": {"test": "target-1"}}}, f)
-            user_db.set_version("test-1", "1.0")
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-2", "1.1", ".click", "info",
-                    "test-2.manifest")) as f:
-                json.dump({"hooks": {"test2-app": {"test": "target-2"}}}, f)
-            user_db.set_version("test-2", "1.1")
+            self._make_installed_click("test-1", "1.0", json_data={
+                "hooks": {"test1-app": {"test": "target-1"}}})
+            self._make_installed_click("test-2", "1.1", json_data={
+                "hooks": {"test2-app": {"test": "target-2"}}})
             path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.test")
             os.symlink(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-1",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-1",
                     "target-1"),
                 path_1)
             path_2 = os.path.join(self.temp_dir, "test-2_test2-app_1.1.test")
             path_3 = os.path.join(self.temp_dir, "test-3_test3-app_1.0.test")
             os.symlink(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-3",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-3",
                     "target-3"),
                 path_3)
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
             hook = Click.Hook.open(self.db, "test")
-            hook.sync(user_name="test-user")
+            hook.sync(user_name=self.TEST_USER)
             self.assertTrue(os.path.lexists(path_1))
             self.assertEqual(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-1",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-1",
                     "target-1"),
                 os.readlink(path_1))
             self.assertTrue(os.path.lexists(path_2))
             self.assertEqual(
                 os.path.join(
-                    self.temp_dir, ".click", "users", "test-user", "test-2",
+                    self.temp_dir, ".click", "users", self.TEST_USER, "test-2",
                     "target-2"),
                 os.readlink(path_2))
             self.assertFalse(os.path.lexists(path_3))
@@ -859,18 +848,15 @@
                     os.path.join(self.temp_dir, "hooks", "test.hook")) as f:
                 print("User-Level: yes", file=f)
                 print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-            with mkfile(os.path.join(
-                    self.temp_dir, "test-package", "1.0", ".click", "info",
-                    "test-package.manifest")) as f:
-                json.dump({"hooks": {"test-app": {"test": "target"}}}, f)
-            all_users_db = Click.User.for_all_users(self.db)
-            all_users_db.set_version("test-package", "1.0")
+            self._make_installed_click(
+                "test-package", "1.0", all_users=True, json_data={
+                    "hooks": {"test-app": {"test": "target"}}})
             self._setup_hooks_dir(
                 preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
             hook = Click.Hook.open(self.db, "test")
-            hook.sync(user_name="test-user")
+            hook.sync(user_name=self.TEST_USER)
             self.assertFalse(os.path.exists(os.path.join(
-                self.temp_dir, ".click", "users", "test-user",
+                self.temp_dir, ".click", "users", self.TEST_USER,
                 "test-package")))
 
     def test_sync_uses_deepest_copy(self):
@@ -911,7 +897,7 @@
             underlay_user_link = os.path.join(
                 underlay, ".click", "users", "@all", "test-package")
             overlay_user_link = os.path.join(
-                overlay, ".click", "users", "test-user", "test-package")
+                overlay, ".click", "users", self.TEST_USER, "test-package")
             Click.ensuredir(os.path.dirname(underlay_user_link))
             os.symlink(underlay_unpacked, underlay_user_link)
             Click.ensuredir(os.path.dirname(overlay_user_link))
@@ -922,7 +908,7 @@
             overlay_target_path = os.path.join(overlay_user_link, "foo")
             os.symlink(overlay_target_path, symlink_path)
             hook = Click.Hook.open(db, "test")
-            hook.sync(user_name="test-user")
+            hook.sync(user_name=self.TEST_USER)
             self.assertTrue(os.path.islink(underlay_user_link))
             self.assertEqual(
                 underlay_unpacked, os.readlink(underlay_user_link))
@@ -962,17 +948,9 @@
             yelp_other_path = os.path.join(
                 self.temp_dir, "yelp", "other-test_app_1.0.txt")
             os.symlink("dummy", yelp_other_path)
-            package_dir = os.path.join(self.temp_dir, "test")
-            with mkfile(os.path.join(
-                    package_dir, "1.0", ".click", "info",
-                    "test.manifest")) as f:
-                json.dump(
-                    {"hooks": {"app": {"yelp": "foo.txt", "unity": "foo.scope"}}},
-                    f)
-            with mkfile(os.path.join(
-                    package_dir, "1.1", ".click", "info",
-                    "test.manifest")) as f:
-                json.dump({}, f)
+            self._make_installed_click("test", "1.0", make_current=False, json_data={
+                "hooks": {"app": {"yelp": "foo.txt", "unity": "foo.scope"}}})
+            self._make_installed_click("test", "1.1", json_data={})
             Click.package_install_hooks(
                 self.db, "test", "1.0", "1.1", user_name=None)
             self.assertFalse(os.path.lexists(unity_path))
@@ -995,15 +973,10 @@
                 print("Hook-Name: b", file=f)
             os.mkdir(os.path.join(self.temp_dir, "a"))
             os.mkdir(os.path.join(self.temp_dir, "b"))
-            package_dir = os.path.join(self.temp_dir, "test")
-            with mkfile(os.path.join(
-                    package_dir, "1.0", ".click", "info",
-                    "test.manifest")) as f:
-                json.dump({"hooks": {}}, f)
-            with mkfile(os.path.join(
-                    package_dir, "1.1", ".click", "info",
-                    "test.manifest")) as f:
-                json.dump({"hooks": {"app": {"a": "foo.a", "b": "foo.b"}}}, f)
+            self._make_installed_click("test", "1.0", make_current=False,
+                                json_data={"hooks": {}})
+            self._make_installed_click("test", "1.1", json_data={
+                "hooks": {"app": {"a": "foo.a", "b": "foo.b"}}})
             Click.package_install_hooks(
                 self.db, "test", "1.0", "1.1", user_name=None)
             self.assertTrue(os.path.lexists(
@@ -1113,3 +1086,95 @@
             self.assertFalse(os.path.lexists(unity_path))
             self.assertFalse(os.path.lexists(yelp_docs_path))
             self.assertFalse(os.path.lexists(yelp_other_path))
+
+
+class TestPackageHooksValidateFramework(TestClickHookBase):
+
+    def _setup_test_env(self, preloads):
+        preloads["click_get_user_home"].return_value = "/home/test-user"
+        self._setup_hooks_dir(
+            preloads, os.path.join(self.temp_dir, "hooks"))
+        self._make_hook_file(dedent("""\
+                           User-Level: yes
+                           Pattern: %s/${id}.test
+        """) % self.temp_dir)
+        self.hook_symlink_path = os.path.join(
+            self.temp_dir, "test-1_test1-app_1.0.test")
+
+    def test_links_are_kept_on_validate_framework(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                "click_get_frameworks_dir",
+                ) as (enter, preloads):
+            enter()
+            self._setup_frameworks(
+                preloads, frameworks=["ubuntu-sdk-13.10"])
+            self._setup_test_env(preloads)
+            self._make_installed_click(json_data={
+                "framework": "ubuntu-sdk-13.10",
+                "hooks": {
+                    "test1-app": {"test": "target-1"}
+                },
+            })
+            self.assertTrue(os.path.lexists(self.hook_symlink_path))
+            # run the hooks
+            Click.run_user_hooks(self.db, user_name=self.TEST_USER)
+            self.assertTrue(os.path.lexists(self.hook_symlink_path))
+
+    def test_links_are_kept_multiple_frameworks(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                "click_get_frameworks_dir",
+                ) as (enter, preloads):
+            enter()
+            self._setup_frameworks(
+                preloads, frameworks=["ubuntu-sdk-14.04", "ubuntu-sdk-13.10"])
+            self._setup_test_env(preloads)
+            self._make_installed_click(json_data={
+                "framework": "ubuntu-sdk-13.10",
+                "hooks": {
+                    "test1-app": {"test": "target-1"}
+                },
+            })
+            self.assertTrue(os.path.lexists(self.hook_symlink_path))
+            # run the hooks
+            Click.run_user_hooks(self.db, user_name=self.TEST_USER)
+            self.assertTrue(os.path.lexists(self.hook_symlink_path))
+
+    def test_links_are_removed_on_missing_framework(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                "click_get_frameworks_dir",
+                ) as (enter, preloads):
+            enter()
+            self._setup_frameworks(preloads, frameworks=["missing"])
+            self._setup_test_env(preloads)
+            self._make_installed_click(json_data={
+                "framework": "ubuntu-sdk-13.10",
+                "hooks": {
+                    "test1-app": {"test": "target-1"}
+                },
+            })
+            self.assertTrue(os.path.lexists(self.hook_symlink_path))
+            # run the hooks
+            Click.run_user_hooks(self.db, user_name=self.TEST_USER)
+            self.assertFalse(os.path.lexists(self.hook_symlink_path))
+
+    def test_links_are_removed_on_missing_multiple_framework(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                "click_get_frameworks_dir",
+                ) as (enter, preloads):
+            enter()
+            self._setup_frameworks(preloads, frameworks=["ubuntu-sdk-13.10"])
+            self._setup_test_env(preloads)
+            self._make_installed_click(json_data={
+                "framework": "ubuntu-sdk-13.10, ubuntu-sdk-13.10-html",
+                "hooks": {
+                    "test1-app": {"test": "target-1"}
+                },
+            })
+            self.assertTrue(os.path.lexists(self.hook_symlink_path))
+            # run the hooks
+            Click.run_user_hooks(self.db, user_name=self.TEST_USER)
+            self.assertFalse(os.path.lexists(self.hook_symlink_path))

=== modified file 'click/tests/test_install.py'
--- click/tests/test_install.py	2014-05-05 13:23:35 +0000
+++ click/tests/test_install.py	2014-05-20 13:13:48 +0000
@@ -43,7 +43,13 @@
     ClickInstallerPermissionDenied,
 )
 from click.preinst import static_preinst
-from click.tests.helpers import TestCase, mkfile, mock, touch
+from click.tests.helpers import (
+    disable_logging,
+    mkfile,
+    mock,
+    TestCase,
+    touch,
+)
 
 
 @contextmanager
@@ -103,14 +109,6 @@
             self.temp_dir, control_dir, data_dir, package_path)
         return package_path
 
-    def _setup_frameworks(self, preloads, frameworks_dir=None, frameworks=[]):
-        frameworks_dir = self._create_mock_framework_dir(frameworks_dir)
-        shutil.rmtree(frameworks_dir, ignore_errors=True)
-        for framework in frameworks:
-            self._create_mock_framework_file(framework)
-        preloads["click_get_frameworks_dir"].side_effect = (
-            lambda: self.make_string(frameworks_dir))
-
     def test_audit_no_click_version(self):
         path = self.make_fake_package()
         self.assertRaisesRegex(
@@ -234,6 +232,7 @@
                 'Framework "missing" not present on system.*',
                 ClickInstaller(self.db).audit, path)
 
+    @disable_logging
     def test_audit_missing_framework_force(self):
         with self.run_in_subprocess(
                 "click_get_frameworks_dir") as (enter, preloads):
@@ -659,6 +658,7 @@
             self.assertTrue(
                 os.path.exists(os.path.join(root, "test-package", "current")))
 
+    @disable_logging
     def test_reinstall_preinstalled(self):
         # Attempting to reinstall a preinstalled version shouldn't actually
         # reinstall it in an overlay database (which would cause

=== modified file 'debian/changelog'
--- debian/changelog	2014-05-14 06:28:34 +0000
+++ debian/changelog	2014-05-20 13:13:48 +0000
@@ -1,3 +1,41 @@
+click (0.4.23.1) UNRELEASED; urgency=medium
+
+  * chroot: Force dpkg-architecture to recalculate everything rather than
+    picking up values from the environment, to avoid the test suite getting
+    confused by environment variables exported by dpkg-buildpackage.
+
+ -- Colin Watson <[e-mail]>  Tue, 20 May 2014 14:12:17 +0100
+
+click (0.4.23) utopic; urgency=medium
+
+  [ Michael Vogt ]
+  * Show human-readable error message when a click chroot subcommand fails
+    because of existing or non-existing chroots (LP: #1296820).
+  * Selectively disable logging on some tests to avoid message spam during
+    the test runs.
+  * When running hooks, remove hook symlinks if framework requirements are
+    not met (LP: #1271944).
+  * Cleanup the chroot if "click chroot create" fails (unless 
+    --keep-broken-chroot is used)
+  * Fix sources.list generation when native_arch and target_arch are on the
+    same archive server (part of LP #1319153).
+  * Add "click framework list" command to list available frameworks
+    (LP: #1294659).
+
+  [ Pete Woods ]
+  * Add libunity-scopes-dev package to chroot (LP: #1320786).
+
+  [ Sergio Schvezov ]
+  * click chroot creation depends on dpkg-architecture, so recommend
+    dpkg-dev.
+
+  [ Colin Watson ]
+  * chroot: Handle the case where we can execute binaries for the target
+    architecture directly and thus don't need a cross-compiler
+    (LP: #1319153).
+
+ -- Colin Watson <[e-mail]>  Tue, 20 May 2014 14:10:11 +0100
+
 click (0.4.22) utopic; urgency=medium
 
   [ Michael Vogt ]

=== modified file 'debian/control'
--- debian/control	2014-03-13 13:56:57 +0000
+++ debian/control	2014-05-20 13:13:48 +0000
@@ -28,7 +28,7 @@
 Architecture: any
 Multi-Arch: foreign
 Depends: ${misc:Depends}, ${perl:Depends}, python3-click (= ${binary:Version})
-Recommends: debootstrap, schroot
+Recommends: debootstrap, schroot, dpkg-dev
 Description: build Click packages
  Click is a simplified packaging format that installs in a separate part of
  the file system, suitable for third-party applications.

=== modified file 'doc/index.rst'
--- doc/index.rst	2014-05-08 12:49:11 +0000
+++ doc/index.rst	2014-05-20 13:13:48 +0000
@@ -38,8 +38,10 @@
 Then run::
 
     $ ./autogen.sh
-    $ ./configure --with-systemdsystemunitdir=/lib/systemd/system \
-	--with-systemduserunitdir=/usr/lib/systemd/user
+    $ ./configure --prefix=/usr \
+        --sysconfdir=/etc \
+        --with-systemdsystemunitdir=/lib/systemd/system \
+        --with-systemduserunitdir=/usr/lib/systemd/user
     $ make
 
 to build the project.

=== modified file 'doc/manpage.rst'
--- doc/manpage.rst	2014-03-18 11:47:21 +0000
+++ doc/manpage.rst	2014-05-20 13:13:48 +0000
@@ -35,6 +35,7 @@
     click buildsource DIRECTORY
     click chroot
     click contents PATH
+    click framework list
     click hook install HOOK
     click hook remove HOOK
     click hook run-system
@@ -148,6 +149,11 @@
 
 Display the contents of the Click package in PATH as a file listing.
 
+click framework list
+--------------------
+
+Display a list of available frameworks as one framework per line.
+
 click hook install HOOK
 -----------------------
 

=== modified file 'lib/click/hooks.vala'
--- lib/click/hooks.vala	2014-04-08 09:31:40 +0000
+++ lib/click/hooks.vala	2014-05-20 13:13:48 +0000
@@ -56,9 +56,57 @@
 	INCOMPLETE
 }
 
+
+/* vala implementation of click.framework.validate_framework()
+ * 
+ * Note that the required_frameworks string has the form
+ *      framework1, framework2, ...
+ * See doc/file-format.rst for details.
+ */
+private bool
+validate_framework (string required_frameworks)
+{
+	// valid framework names, cf. debian policy §5.6.1
+	Regex valid_framework_re;
+	try {
+		valid_framework_re = new Regex ("^[a-z][a-z0-9.+-]+");
+	} catch (RegexError e) {
+		error ("Could not compile regex /^[a-z][a-z0-9.+-]+/: %s",
+		       e.message);
+	}
+	var base_version = "";
+	foreach (var framework_name in required_frameworks.split (","))
+	{
+		framework_name = framework_name.strip ();
+		if (!valid_framework_re.match (framework_name))
+			return false;
+		Framework framework;
+		// now check the base-version
+		try {
+			framework = Framework.open (framework_name);
+		} catch (FrameworkError e) {
+			return false;
+		}
+		if (base_version == "")
+			base_version = framework.get_base_version ();
+		if (base_version != framework.get_base_version ())
+			return false;
+	}
+	return true;
+}
+
+private bool
+validate_framework_for_package (DB db, string package, string? version)
+{
+	var manifest = read_manifest (db, package, version);
+	if (!manifest.has_member ("framework"))
+		return true;
+	var required_frameworks = manifest.get_string_member ("framework");
+	return validate_framework (required_frameworks);
+}
+
 private Json.Object
-read_manifest_hooks (DB db, string package, string? version)
-	throws DatabaseError
+read_manifest (DB db, string package, string? version)
 {
 	if (version == null)
 		return new Json.Object ();
@@ -69,15 +117,22 @@
 			 @"$package.manifest");
 		parser.load_from_file (manifest_path);
 		var manifest = parser.get_root ().get_object ();
-		if (! manifest.has_member ("hooks"))
-			return new Json.Object ();
-		var hooks = manifest.get_object_member ("hooks");
-		return hooks.ref ();
+		return manifest.ref ();
 	} catch (Error e) {
 		return new Json.Object ();
 	}
 }
 
+private Json.Object
+read_manifest_hooks (DB db, string package, string? version)
+{
+	var manifest = read_manifest (db, package, version);
+	if (! manifest.has_member ("hooks"))
+		return new Json.Object ();
+	var hooks = manifest.get_object_member ("hooks");
+	return hooks.ref ();
+}
+
 private class PreviousEntry : Object, Gee.Hashable<PreviousEntry> {
 	public string path { get; construct; }
 	public string package { get; construct; }
@@ -889,10 +944,16 @@
 		var ret = new List<RelevantApp> ();
 		var hook_name = get_hook_name ();
 		foreach (var unpacked in get_all_packages (user_name)) {
-			var manifest = read_manifest_hooks
+			// if the app is not using a valid framework (anymore)
+			// we don't consider it relevant (anymore)
+			if (!validate_framework_for_package 
+				    (db, unpacked.package, unpacked.version))
+				continue;
+
+			var manifest_hooks = read_manifest_hooks
 				(db, unpacked.package, unpacked.version);
-			foreach (var app_name in manifest.get_members ()) {
-				var hooks = manifest.get_object_member
+			foreach (var app_name in manifest_hooks.get_members ()) {
+				var hooks = manifest_hooks.get_object_member
 					(app_name);
 				if (hooks.has_member (hook_name)) {
 					var relative_path = hooks.get_string_member
@@ -960,6 +1021,7 @@
 			unowned string package = app.package;
 			unowned string version = app.version;
 			unowned string app_name = app.app_name;
+
 			seen.add (@"$(package)_$(app_name)_$(version)");
 			if (is_user_level) {
 				var user_db = new User.for_user
@@ -1016,7 +1078,7 @@
  * @new_version: The new version of the package.
  * @user_name: (allow-none): A user name, or null.
  *
- * Run hooks following removal of a Click package.
+ * Run hooks following install of a Click package.
  *
  * If @user_name is null, only run system-level hooks.  If @user_name is not
  * null, only run user-level hooks for that user.