Merge lp:~cjwatson/click/libclick into lp:click

[Colin Watson]

Hi Thomas. You volunteered your services as a reviewer. I still have a good deal of proofreading and testing to do on this, but I think it's reached the point where it's worth another reviewer having a look in parallel.

This is the first (and most probably largest) chunk of libclick. The core of it is a reasonably literal translation of several of click's Python modules to Vala. This part is fairly straightforward, though I took as much care as I could to keep the public ABI down to only what I'm prepared to keep stable; Vala helped but I couldn't get it to stop exposing some internal methods, so I resorted to libtool -export-symbols.

The really difficult bit was getting the test suite going (and I'd have had essentially the same issues with C). I wanted to satisfy the following constraints:

 * Don't rewrite the test suite at the same time as the code. In fact I'm quite happy with the test suite staying in Python permanently, but I definitely wanted to be able to run the existing test suite over the new code to validate the translation, with only relatively minor per-test changes.
 * Preserve the ability to insert mock functions.
 * Don't require relinking the library to run tests against it. This is a popular strategy for inserting mock functions in C, but I'm not comfortable with this level of interference with the code under test.

After a good deal of experimentation, I managed to get an initial version of this working, by generating LD_PRELOADable objects on the fly, using gobject-introspection to extract function signatures in a way that should hopefully be reasonably maintainable, and using ctypes to generate callbacks to Python methods and injecting pointers to those functions into the preloaded object. Affected tests must go through fork+execve in order that the dynamic loader can deal with LD_PRELOAD. I left an extensive header comment to explain how all this works. It's a bit fragile in various ways, and requires some manual maintenance of function declarations and structure contents (the handling of "struct stat" is particularly gnarly), but it pays off at the per-test level. I expect to start a new project implementing these general techniques reasonably soon, but I think it's worth having this in click for the time being rather than blocking on applying gold-plating.

[lp:~cjwatson/click/libclick]

352. By Colin Watson on 2014-03-03

Keep to <80 columns.

353. By Colin Watson on 2014-03-03

Fix bug in Vala conversion of find_on_path: only regular files should count.

354. By Colin Watson on 2014-03-03

Remove unnecessary PosixExtra versions of setgrent and endgrent.

355. By Colin Watson on 2014-03-03

Fix infinite loop if Vala version of find_package_directory reaches "/".

356. By Colin Watson on 2014-03-03

lib/click/database.vala: Clear errno before calling getpwnam so that we can detect errors. (We already did this elsewhere.)

357. By Colin Watson on 2014-03-03

lib/click/user.vala: Might as well use our "exists" helper here too.

358. By Colin Watson on 2014-03-03

Use has_package_name in User.is_removable for brevity and to be closer to the original Python code.

359. By Colin Watson on 2014-03-04

Simplify Hooks.open_all slightly.

360. By Colin Watson on 2014-03-04

Relink library if lib/click/click.sym changes.

[Colin Watson (cjwatson)]

There are several bugs I'd want to tackle after this, collected here:

  https://bugs.launchpad.net/ubuntu/+source/click/+bugs?field.tag=libclick

[lp:~cjwatson/click/libclick]

361. By Colin Watson on 2014-03-04

merge trunk

362. By Colin Watson on 2014-03-04

Hook Exec lines must be run using /bin/sh; Shell.parse_argv isn't enough, as Exec may contain more than just a simple command.

363. By Colin Watson on 2014-03-05

Add a run-click script to run bin/click from the build tree; useful during development.

364. By Colin Watson on 2014-03-05

merge trunk

365. By Colin Watson on 2014-03-05

When creating a User, implicitly create a DB if none was provided. This is convenient for the common case of quick lookups in clients.

366. By Colin Watson on 2014-03-06

Remove "#include <gee.h>" from our external header file.

367. By Colin Watson on 2014-03-06

libclick-0.4-dev needs to depend on libglib2.0-dev for <glib.h> and <glib-object.h>.

[Colin Watson (cjwatson)]

I chatted with Thomas about this today. He doesn't think he's going to want major rework, although would like to carry on reviewing. We agreed that I would go ahead and land this anyway (since libclick is blocking other things, and it would be good to try to squeeze it in before Qt 5.2 breaks landing for however many days), and if he finds issues that I need to bump soname for then so be it.

(Let me know if anything here is inaccurate.)

=== modified file '.bzrignore'
--- .bzrignore	2014-03-05 16:36:20 +0000
+++ .bzrignore	2014-03-06 07:04:44 +0000
@@ -27,6 +27,8 @@
 dist
 .tox
 click/paths.py
+click/tests/config.py
+click/tests/preload.gir
 build-aux/compile
 build-aux/config.guess
 build-aux/config.rpath
@@ -44,6 +46,9 @@
 debian/click
 debian/click-doc
 debian/files
+debian/gir1.2-click-0.4
+debian/libclick-0.4-0
+debian/libclick-0.4-dev
 debian/packagekit-plugin-click
 debian/python3-click
 debian/tmp
@@ -51,6 +56,15 @@
 init/systemd/click-user-hooks.service
 init/upstart/click-system-hooks.conf
 init/upstart/click-user-hooks.conf
+lib/click/*.c
+lib/click/*.gir
+lib/click/*.typelib
+lib/click/click.h
+lib/click/click-0.4.pc
+lib/click/click-0.4.vapi
+lib/click/libclick_0_4_la_vala.stamp
+lib/click/paths.vala
+lib/click/valac-wrapper
 m4/*
 pk-plugin/com.ubuntu.click.policy
 po/.intltool-merge-cache
 
=== modified file 'Makefile.am'
--- Makefile.am	2014-03-05 16:36:20 +0000
+++ Makefile.am	2014-03-06 07:04:44 +0000
@@ -1,4 +1,4 @@
-SUBDIRS = click conf debhelper init po preload schroot
+SUBDIRS = lib preload click conf debhelper init po schroot
 if PACKAGEKIT
 SUBDIRS += pk-plugin
 endif
 
=== modified file 'click/Makefile.am'
--- click/Makefile.am	2013-09-03 12:50:11 +0000
+++ click/Makefile.am	2014-03-06 07:04:44 +0000
@@ -1,3 +1,5 @@
+SUBDIRS = tests
+
 noinst_SCRIPTS = paths.py
 CLEANFILES = $(noinst_SCRIPTS)
 
 
=== modified file 'click/commands/desktophook.py'
--- click/commands/desktophook.py	2013-09-30 09:14:02 +0000
+++ click/commands/desktophook.py	2014-03-06 07:04:44 +0000
@@ -23,8 +23,9 @@
 from optparse import OptionParser
 import os
 
+from gi.repository import Click
+
 from click import osextras
-from click.query import find_package_directory
 
 
 COMMENT = \
@@ -71,7 +72,7 @@
 
 def read_hooks_for(path, package, app_name):
     try:
-        directory = find_package_directory(path)
+        directory = Click.find_package_directory(path)
         manifest_path = os.path.join(
             directory, ".click", "info", "%s.manifest" % package)
         with io.open(manifest_path, encoding="UTF-8") as manifest:
@@ -111,10 +112,10 @@
 # TODO: This is a very crude .desktop file mangler; we should instead
 # implement proper (de)serialisation.
 def write_desktop_file(target_path, source_path, profile):
-    osextras.ensuredir(os.path.dirname(target_path))
+    Click.ensuredir(os.path.dirname(target_path))
     with io.open(source_path, encoding="UTF-8") as source, \
          io.open(target_path, "w", encoding="UTF-8") as target:
-        source_dir = find_package_directory(source_path)
+        source_dir = Click.find_package_directory(source_path)
         written_comment = False
         seen_path = False
         for line in source:
 
=== modified file 'click/commands/hook.py'
--- click/commands/hook.py	2013-09-20 11:07:55 +0000
+++ click/commands/hook.py	2014-03-06 07:04:44 +0000
@@ -20,8 +20,7 @@
 from optparse import OptionParser
 from textwrap import dedent
 
-from click.database import ClickDB
-from click.hooks import ClickHook, run_system_hooks, run_user_hooks
+from gi.repository import Click
 
 
 per_hook_subcommands = {
@@ -54,16 +53,25 @@
     if subcommand in per_hook_subcommands:
         if len(args) < 2:
             parser.error("need hook name")
-        db = ClickDB(options.root)
+        db = Click.DB()
+        db.read()
+        if options.root is not None:
+            db.add(options.root)
         name = args[1]
-        hook = ClickHook.open(db, name)
+        hook = Click.Hook.open(db, name)
         getattr(hook, per_hook_subcommands[subcommand])()
     elif subcommand == "run-system":
-        db = ClickDB(options.root)
-        run_system_hooks(db)
+        db = Click.DB()
+        db.read()
+        if options.root is not None:
+            db.add(options.root)
+        Click.run_system_hooks(db)
     elif subcommand == "run-user":
-        db = ClickDB(options.root)
-        run_user_hooks(db, user=options.user)
+        db = Click.DB()
+        db.read()
+        if options.root is not None:
+            db.add(options.root)
+        Click.run_user_hooks(db, user_name=options.user)
     else:
         parser.error(
             "unknown subcommand '%s' (known: install, remove, run-system,"
 
=== modified file 'click/commands/info.py'
--- click/commands/info.py	2013-09-30 09:20:16 +0000
+++ click/commands/info.py	2014-03-06 07:04:44 +0000
@@ -24,18 +24,21 @@
 import os
 import sys
 
-from click.database import ClickDB
+from gi.repository import Click
+
 from click.install import DebFile
-from click.user import ClickUser
 
 
 def get_manifest(options, arg):
     if "/" not in arg:
-        db = ClickDB(options.root)
-        registry = ClickUser(db, user=options.user)
-        if arg in registry:
+        db = Click.DB()
+        db.read()
+        if options.root is not None:
+            db.add(options.root)
+        registry = Click.User.for_user(db, name=options.user)
+        if registry.has_package_name(arg):
             manifest_path = os.path.join(
-                registry.path(arg), ".click", "info", "%s.manifest" % arg)
+                registry.get_path(arg), ".click", "info", "%s.manifest" % arg)
             with io.open(manifest_path, encoding="UTF-8") as manifest:
                 return json.load(manifest)
 
 
=== modified file 'click/commands/install.py'
--- click/commands/install.py	2013-10-22 10:44:43 +0000
+++ click/commands/install.py	2014-03-06 07:04:44 +0000
@@ -21,7 +21,8 @@
 import sys
 from textwrap import dedent
 
-from click.database import ClickDB
+from gi.repository import Click
+
 from click.install import ClickInstaller, ClickInstallerError
 
 
@@ -45,7 +46,10 @@
     options, args = parser.parse_args(argv)
     if len(args) < 1:
         parser.error("need package file name")
-    db = ClickDB(options.root)
+    db = Click.DB()
+    db.read()
+    if options.root is not None:
+        db.add(options.root)
     package_path = args[0]
     installer = ClickInstaller(db, options.force_missing_framework)
     try:
 
=== modified file 'click/commands/list.py'
--- click/commands/list.py	2013-09-30 09:14:02 +0000
+++ click/commands/list.py	2014-03-06 07:04:44 +0000
@@ -23,22 +23,25 @@
 import os
 import sys
 
-from click.database import ClickDB
-from click.user import ClickUser
+from gi.repository import Click
 
 
 def list_packages(options):
-    db = ClickDB(options.root)
+    db = Click.DB()
+    db.read()
+    if options.root is not None:
+        db.add(options.root)
     if options.all:
-        for package, version, path, writeable in \
-                db.packages(all_versions=True):
-            yield package, version, path, writeable
+        for inst in db.get_packages(all_versions=True):
+            yield (
+                inst.props.package, inst.props.version, inst.props.path,
+                inst.props.writeable)
     else:
-        registry = ClickUser(db, user=options.user)
-        for package, version in sorted(registry.items()):
+        registry = Click.User.for_user(db, name=options.user)
+        for package in sorted(registry.get_package_names()):
             yield (
-                package, version, registry.path(package),
-                registry.removable(package))
+                package, registry.get_version(package),
+                registry.get_path(package), registry.is_removable(package))
 
 
 def run(argv):
 
=== modified file 'click/commands/pkgdir.py'
--- click/commands/pkgdir.py	2013-09-16 12:44:40 +0000
+++ click/commands/pkgdir.py	2014-03-06 07:04:44 +0000
@@ -21,9 +21,7 @@
 from optparse import OptionParser
 import sys
 
-from click.database import ClickDB
-from click.query import find_package_directory
-from click.user import ClickUser
+from gi.repository import Click
 
 
 def run(argv):
@@ -39,12 +37,15 @@
         parser.error("need package name")
     try:
         if "/" in args[0]:
-            print(find_package_directory(args[0]))
+            print(Click.find_package_directory(args[0]))
         else:
-            db = ClickDB(options.root)
+            db = Click.DB()
+            db.read()
+            if options.root is not None:
+                db.add(options.root)
             package_name = args[0]
-            registry = ClickUser(db, user=options.user)
-            print(registry.path(package_name))
+            registry = Click.User(db, name=options.user)
+            print(registry.get_path(package_name))
     except Exception as e:
         print(e, file=sys.stderr)
         return 1
 
=== modified file 'click/commands/register.py'
--- click/commands/register.py	2013-09-30 09:14:02 +0000
+++ click/commands/register.py	2014-03-06 07:04:44 +0000
@@ -19,8 +19,7 @@
 
 from optparse import OptionParser
 
-from click.database import ClickDB
-from click.user import ClickUser
+from gi.repository import Click, GLib
 
 
 def run(argv):
@@ -38,11 +37,20 @@
         parser.error("need package name")
     if len(args) < 2:
         parser.error("need version")
-    db = ClickDB(options.root)
+    db = Click.DB()
+    db.read()
+    if options.root is not None:
+        db.add(options.root)
     package = args[0]
     version = args[1]
-    registry = ClickUser(db, user=options.user, all_users=options.all_users)
-    old_version = registry.get(package)
+    if options.all_users:
+        registry = Click.User.for_all_users(db)
+    else:
+        registry = Click.User.for_user(db, name=options.user)
+    try:
+        old_version = registry.get_version(package)
+    except GLib.GError:
+        old_version = None
     registry.set_version(package, version)
     if old_version is not None:
         db.maybe_remove(package, old_version)
 
=== modified file 'click/commands/unregister.py'
--- click/commands/unregister.py	2013-09-30 09:14:02 +0000
+++ click/commands/unregister.py	2014-03-06 07:04:44 +0000
@@ -21,8 +21,7 @@
 import os
 import sys
 
-from click.database import ClickDB
-from click.user import ClickUser
+from gi.repository import Click
 
 
 def run(argv):
@@ -44,10 +43,16 @@
             "remove packages from disk")
     if options.user is None and "SUDO_USER" in os.environ:
         options.user = os.environ["SUDO_USER"]
-    db = ClickDB(options.root)
+    db = Click.DB()
+    db.read()
+    if options.root is not None:
+        db.add(options.root)
     package = args[0]
-    registry = ClickUser(db, user=options.user, all_users=options.all_users)
-    old_version = registry[package]
+    if options.all_users:
+        registry = Click.User.for_all_users(db)
+    else:
+        registry = Click.User.for_user(db, name=options.user)
+    old_version = registry.get_version(package)
     if len(args) >= 2 and old_version != args[1]:
         print(
             "Not removing %s %s; expected version %s" %
 
=== removed file 'click/database.py'
--- click/database.py	2013-12-10 14:33:19 +0000
+++ click/database.py	1970-01-01 00:00:00 +0000
@@ -1,323 +0,0 @@
-# Copyright (C) 2013 Canonical Ltd.
-# Author: Colin Watson <[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/>.
-
-"""Click databases."""
-
-from __future__ import print_function
-
-__metaclass__ = type
-__all__ = [
-    "ClickDB",
-    ]
-
-
-from collections import Sequence, defaultdict
-import io
-import json
-import os
-import pwd
-import shutil
-import subprocess
-import sys
-
-try:
-    from configparser import Error as ConfigParserError
-    if sys.version < "3.2":
-        from configparser import SafeConfigParser as ConfigParser
-    else:
-        from configparser import ConfigParser
-except ImportError:
-    from ConfigParser import Error as ConfigParserError
-    from ConfigParser import SafeConfigParser as ConfigParser
-
-from click import osextras
-from click.paths import db_dir
-
-
-class ClickSingleDB:
-    def __init__(self, root, master_db):
-        self.root = root
-        self.master_db = master_db
-
-    def path(self, package, version):
-        """Look up a package and version in only this database."""
-        try_path = os.path.join(self.root, package, version)
-        if os.path.exists(try_path):
-            return try_path
-        else:
-            raise KeyError(
-                "%s %s does not exist in %s" % (package, version, self.root))
-
-    def packages(self, all_versions=False):
-        """Return all current package versions in only this database.
-
-        If all_versions=True, return all versions, not just current ones.
-        """
-        for package in sorted(osextras.listdir_force(self.root)):
-            if package == ".click":
-                continue
-            if all_versions:
-                package_path = os.path.join(self.root, package)
-                for version in sorted(osextras.listdir_force(package_path)):
-                    version_path = os.path.join(package_path, version)
-                    if (os.path.islink(version_path) or
-                            not os.path.isdir(version_path)):
-                        continue
-                    yield package, version, version_path
-            else:
-                current_path = os.path.join(self.root, package, "current")
-                if os.path.islink(current_path):
-                    version = os.readlink(current_path)
-                    if "/" not in version:
-                        yield package, version, current_path
-
-    def _app_running(self, package, app_name, version):
-        app_id = "%s_%s_%s" % (package, app_name, version)
-        command = ["upstart-app-pid", app_id]
-        with open("/dev/null", "w") as devnull:
-            return subprocess.call(command, stdout=devnull) == 0
-
-    def _any_app_running(self, package, version):
-        if not osextras.find_on_path("upstart-app-pid"):
-            return False
-        manifest_path = os.path.join(
-            self.path(package, version), ".click", "info",
-            "%s.manifest" % package)
-        try:
-            with io.open(manifest_path, encoding="UTF-8") as manifest:
-                manifest_json = json.load(manifest)
-            for app_name in manifest_json.get("hooks", {}):
-                if self._app_running(package, app_name, version):
-                    return True
-        except Exception:
-            pass
-        return False
-
-    def _remove_unless_running(self, package, version, verbose=False):
-        # Circular imports.
-        from click.hooks import package_remove_hooks
-        from click.user import ClickUser, GC_IN_USE_USER
-
-        if self._any_app_running(package, version):
-            gc_in_use_user_db = ClickUser(self.master_db, user=GC_IN_USE_USER)
-            gc_in_use_user_db.set_version(package, version)
-            return
-
-        version_path = self.path(package, version)
-        if verbose:
-            print("Removing %s" % version_path)
-        package_remove_hooks(self, package, version)
-        shutil.rmtree(version_path, ignore_errors=True)
-
-        package_path = os.path.join(self.root, package)
-        current_path = os.path.join(package_path, "current")
-        if (os.path.islink(current_path) and
-                os.readlink(current_path) == version):
-            os.unlink(current_path)
-            # TODO: Perhaps we should relink current to the latest remaining
-            # version.  However, that requires version comparison, and it's
-            # not clear whether it's worth it given that current is mostly
-            # superseded by user registration.
-        if not os.listdir(package_path):
-            os.rmdir(package_path)
-
-    def maybe_remove(self, package, version):
-        """Remove a package version if it is not in use.
-
-        "In use" may mean registered for another user, or running.  In the
-        latter case we construct a fake registration so that we can tell the
-        difference later between a package version that was in use at the
-        time of removal and one that was never registered for any user.
-
-        (This is unfortunately complex, and perhaps some day we can require
-        that installations always have some kind of registration to avoid
-        this complexity.)
-        """
-        # Circular imports.
-        from click.user import ClickUsers, GC_IN_USE_USER
-
-        for user_name, user_db in ClickUsers(self.master_db).items():
-            if user_db.get(package) == version:
-                if user_name == GC_IN_USE_USER:
-                    # Previously running; we'll check this again shortly.
-                    user_db.remove(package)
-                else:
-                    # In use.
-                    return
-
-        self._remove_unless_running(package, version)
-
-    def gc(self, verbose=True):
-        """Remove package versions with no user registrations.
-
-        To avoid accidentally removing packages that were installed without
-        ever having a user registration, we only garbage-collect packages
-        that were not removed by ClickSingleDB.maybe_remove due to having a
-        running application at the time.
-
-        (This is unfortunately complex, and perhaps some day we can require
-        that installations always have some kind of registration to avoid
-        this complexity.)
-        """
-        # Circular import.
-        from click.user import ClickUser, ClickUsers, GC_IN_USE_USER
-
-        user_reg = defaultdict(set)
-        gc_in_use = defaultdict(set)
-        for user_name, user_db in ClickUsers(self.master_db).items():
-            for package, version in user_db.items():
-                if user_name == GC_IN_USE_USER:
-                    gc_in_use[package].add(version)
-                else:
-                    user_reg[package].add(version)
-
-        gc_in_use_user_db = ClickUser(self.master_db, user=GC_IN_USE_USER)
-        for package in sorted(osextras.listdir_force(self.root)):
-            if package == ".click":
-                continue
-            package_path = os.path.join(self.root, package)
-            for version in sorted(osextras.listdir_force(package_path)):
-                if version in user_reg[package]:
-                    # In use.
-                    continue
-                if version not in gc_in_use[package]:
-                    version_path = os.path.join(package_path, version)
-                    if verbose:
-                        print(
-                            "Not removing %s (never registered)." %
-                            version_path)
-                    continue
-                gc_in_use_user_db.remove(package)
-                self._remove_unless_running(package, version, verbose=verbose)
-
-    def _clickpkg_paths(self):
-        """Yield all paths which should be owned by clickpkg."""
-        if os.path.exists(self.root):
-            yield self.root
-        for package in osextras.listdir_force(self.root):
-            if package == ".click":
-                path = os.path.join(self.root, ".click")
-                yield path
-                log_path = os.path.join(path, "log")
-                if os.path.exists(log_path):
-                    yield log_path
-                users_path = os.path.join(path, "users")
-                if os.path.exists(users_path):
-                    yield users_path
-            else:
-                path = os.path.join(self.root, package)
-                for dirpath, dirnames, filenames in os.walk(path):
-                    yield dirpath
-                    for dirname in dirnames:
-                        dirname_path = os.path.join(dirpath, dirname)
-                        if os.path.islink(dirname_path):
-                            yield dirname_path
-                    for filename in filenames:
-                        yield os.path.join(dirpath, filename)
-
-    def ensure_ownership(self):
-        """Ensure correct ownership of files in the database.
-
-        On a system that is upgraded by delivering a new system image rather
-        than by package upgrades, it is possible for the clickpkg UID to
-        change.  The overlay database must then be adjusted to account for
-        this.
-        """
-        pw = pwd.getpwnam("clickpkg")
-        try:
-            st = os.stat(self.root)
-            if st.st_uid == pw.pw_uid and st.st_gid == pw.pw_gid:
-                return
-        except OSError:
-            return
-        chown_kwargs = {}
-        if sys.version >= "3.3" and os.chown in os.supports_follow_symlinks:
-            chown_kwargs["follow_symlinks"] = False
-        for path in self._clickpkg_paths():
-            os.chown(path, pw.pw_uid, pw.pw_gid, **chown_kwargs)
-
-
-class ClickDB(Sequence):
-    def __init__(self, extra_root=None, use_system=True, override_db_dir=None):
-        if override_db_dir is None:
-            override_db_dir = db_dir
-        self._db = []
-        if use_system:
-            for entry in sorted(osextras.listdir_force(override_db_dir)):
-                if not entry.endswith(".conf"):
-                    continue
-                path = os.path.join(override_db_dir, entry)
-                config = ConfigParser()
-                try:
-                    config.read(path)
-                    root = config.get("Click Database", "root")
-                except ConfigParserError as e:
-                    print(e, file=sys.stderr)
-                    continue
-                self.add(root)
-        if extra_root is not None:
-            self.add(extra_root)
-
-    def __getitem__(self, key):
-        return self._db[key]
-
-    def __len__(self):
-        return len(self._db)
-
-    def add(self, root):
-        self._db.append(ClickSingleDB(root, self))
-
-    @property
-    def overlay(self):
-        """Return the directory where changes should be written."""
-        return self._db[-1].root
-
-    def path(self, package, version):
-        """Look up a package and version in all databases."""
-        for db in reversed(self._db):
-            try:
-                return db.path(package, version)
-            except KeyError:
-                pass
-        else:
-            raise KeyError(
-                "%s %s does not exist in any database" % (package, version))
-
-    def packages(self, all_versions=False):
-        """Return current package versions in all databases.
-
-        If all_versions=True, return all versions, not just current ones.
-        """
-        seen = set()
-        for db in reversed(self._db):
-            writeable = db is self._db[-1]
-            for package, version, path in \
-                    db.packages(all_versions=all_versions):
-                if all_versions:
-                    seen_id = (package, version)
-                else:
-                    seen_id = package
-                if seen_id not in seen:
-                    yield package, version, path, writeable
-                    seen.add(seen_id)
-
-    def maybe_remove(self, package, version):
-        self._db[-1].maybe_remove(package, version)
-
-    def gc(self, verbose=True):
-        self._db[-1].gc(verbose=verbose)
-
-    def ensure_ownership(self):
-        self._db[-1].ensure_ownership()
 
=== removed file 'click/hooks.py'
--- click/hooks.py	2014-02-19 15:31:55 +0000
+++ click/hooks.py	1970-01-01 00:00:00 +0000
@@ -1,438 +0,0 @@
-# Copyright (C) 2013 Canonical Ltd.
-# Author: Colin Watson <[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/>.
-
-"""Click package hooks.
-
-See doc/hooks.rst for the draft specification.
-"""
-
-from __future__ import print_function
-
-__metaclass__ = type
-__all__ = [
-    "ClickHook",
-    "package_install_hooks",
-    "run_system_hooks",
-    "run_user_hooks",
-    ]
-
-from functools import partial
-import grp
-import io
-import json
-import os
-import pwd
-import re
-from string import Formatter
-import subprocess
-
-from debian.deb822 import Deb822
-
-from click import osextras
-from click.paths import hooks_dir
-from click.user import ClickUser, ClickUsers
-
-
-def _read_manifest_hooks(db, package, version):
-    if version is None:
-        return {}
-    try:
-        manifest_path = os.path.join(
-            db.path(package, version), ".click", "info",
-            "%s.manifest" % package)
-        with io.open(manifest_path, encoding="UTF-8") as manifest:
-            return json.load(manifest).get("hooks", {})
-    except (KeyError, IOError):
-        return {}
-
-
-class ClickPatternFormatter(Formatter):
-    """A Formatter that handles simple $-expansions.
-
-    `${key}` is replaced by the value of the `key` argument; `$$` is
-    replaced by `$`.  Any `$` character not followed by `{...}` or `$` is
-    preserved intact.
-    """
-    _expansion_re = re.compile(r"\$(?:\$|{(.*?)})")
-
-    def parse(self, format_string):
-        while True:
-            match = self._expansion_re.search(format_string)
-            if match is None:
-                if format_string:
-                    yield format_string, None, None, None
-                return
-            start, end = match.span()
-            if format_string[match.start():match.end()] == "$$":
-                yield format_string[:match.start() + 1], None, None, None
-            else:
-                yield format_string[:match.start()], match.group(1), "", None
-            format_string = format_string[match.end():]
-
-    def get_field(self, field_name, args, kwargs):
-        value = kwargs.get(field_name)
-        if value is None:
-            value = ""
-        return value, field_name
-
-    def possible_expansion(self, s, format_string, *args, **kwargs):
-        """Check if s is a possible expansion.
-
-        Any (keyword) arguments have the effect of binding some keys to
-        fixed values; unspecified keys may take any value, and will bind
-        greedily to the longest possible string.
-
-        If s is a possible expansion, then this method returns a (possibly
-        empty) dictionary mapping all the unspecified keys to their bound
-        values.  Otherwise, it returns None.
-        """
-        ret = {}
-        regex_pieces = []
-        group_names = []
-        for literal_text, field_name, format_spec, conversion in \
-                self.parse(format_string):
-            if literal_text:
-                regex_pieces.append(re.escape(literal_text))
-            if field_name is not None:
-                if field_name in kwargs:
-                    regex_pieces.append(re.escape(kwargs[field_name]))
-                else:
-                    regex_pieces.append("(.*)")
-                    group_names.append(field_name)
-        match = re.match("^%s$" % "".join(regex_pieces), s)
-        if match is None:
-            return None
-        for group in range(len(group_names)):
-            ret[group_names[group]] = match.group(group + 1)
-        return ret
-
-
-class ClickHook(Deb822):
-    _formatter = ClickPatternFormatter()
-
-    def __init__(self, db, name, sequence=None, fields=None, encoding="utf-8"):
-        super(ClickHook, self).__init__(
-            sequence=sequence, fields=fields, encoding=encoding)
-        self.db = db
-        self.name = name
-
-    @classmethod
-    def open(cls, db, name):
-        try:
-            with open(os.path.join(hooks_dir, "%s.hook" % name)) as f:
-                return cls(db, name, f)
-        except IOError:
-            raise KeyError("No click hook '%s' installed" % name)
-
-    @classmethod
-    def open_all(cls, db, hook_name=None):
-        for entry in osextras.listdir_force(hooks_dir):
-            if not entry.endswith(".hook"):
-                continue
-            try:
-                with open(os.path.join(hooks_dir, entry)) as f:
-                    hook = cls(db, entry[:-5], f)
-                    if hook_name is None or hook.hook_name == hook_name:
-                        yield hook
-            except IOError:
-                pass
-
-    @property
-    def user_level(self):
-        return self.get("user-level", "no") == "yes"
-
-    @property
-    def single_version(self):
-        return self.user_level or self.get("single-version", "no") == "yes"
-
-    @property
-    def hook_name(self):
-        return self.get("hook-name", self.name)
-
-    def short_app_id(self, package, app_name):
-        # TODO: perhaps this check belongs further up the stack somewhere?
-        if "_" in app_name or "/" in app_name:
-            raise ValueError(
-                "Application name '%s' may not contain _ or / characters" %
-                app_name)
-        return "%s_%s" % (package, app_name)
-
-    def app_id(self, package, version, app_name):
-        return "%s_%s" % (self.short_app_id(package, app_name), version)
-
-    def _user_home(self, user):
-        if user is None:
-            return None
-        # TODO: make robust against removed users
-        # TODO: caching
-        return pwd.getpwnam(user).pw_dir
-
-    def pattern(self, package, version, app_name, user=None):
-        app_id = self.app_id(package, version, app_name)
-        kwargs = {
-            "id": app_id,
-            "user": user,
-            "home": self._user_home(user),
-            }
-        if self.single_version:
-            kwargs["short-id"] = self.short_app_id(package, app_name)
-        return self._formatter.format(self["pattern"], **kwargs).rstrip(os.sep)
-
-    def _drop_privileges(self, username):
-        if os.geteuid() != 0:
-            return
-        pw = pwd.getpwnam(username)
-        os.setgroups(
-            [g.gr_gid for g in grp.getgrall() if username in g.gr_mem])
-        # Portability note: this assumes that we have [gs]etres[gu]id, which
-        # is true on Linux but not necessarily elsewhere.  If you need to
-        # support something else, there are reasonably standard alternatives
-        # involving other similar calls; see e.g. gnulib/lib/idpriv-drop.c.
-        os.setresgid(pw.pw_gid, pw.pw_gid, pw.pw_gid)
-        os.setresuid(pw.pw_uid, pw.pw_uid, pw.pw_uid)
-        assert os.getresuid() == (pw.pw_uid, pw.pw_uid, pw.pw_uid)
-        assert os.getresgid() == (pw.pw_gid, pw.pw_gid, pw.pw_gid)
-        os.environ["HOME"] = pw.pw_dir
-        os.umask(osextras.get_umask() | 0o002)
-
-    def _run_commands_user(self, user=None):
-        if self.user_level:
-            return user
-        else:
-            return self["user"]
-
-    def _run_commands(self, user=None):
-        if "exec" in self:
-            drop_privileges = partial(
-                self._drop_privileges, self._run_commands_user(user=user))
-            subprocess.check_call(
-                self["exec"], preexec_fn=drop_privileges, shell=True)
-        if self.get("trigger", "no") == "yes":
-            raise NotImplementedError("'Trigger: yes' not yet implemented")
-
-    def _previous_entries(self, user=None):
-        """Find entries that match the structure of our links."""
-        link_dir = os.path.dirname(self.pattern("", "", "", user=user))
-        # TODO: This only works if the app ID only appears, at most, in the
-        # last component of the pattern path.
-        for previous_entry in osextras.listdir_force(link_dir):
-            previous_path = os.path.join(link_dir, previous_entry)
-            previous_exp = self._formatter.possible_expansion(
-                previous_path, self["pattern"], user=user,
-                home=self._user_home(user))
-            if previous_exp is None or "id" not in previous_exp:
-                continue
-            previous_id = previous_exp["id"]
-            try:
-                previous_package, previous_app_name, previous_version = (
-                    previous_id.split("_", 2))
-                yield (
-                    previous_path,
-                    previous_package, previous_version, previous_app_name)
-            except ValueError:
-                continue
-
-    def _install_link(self, package, version, app_name, relative_path,
-                      user=None, user_db=None):
-        """Install a hook symlink.
-
-        This should be called with dropped privileges if necessary.
-        """
-        if self.user_level:
-            target = os.path.join(user_db.path(package), relative_path)
-        else:
-            target = os.path.join(
-                self.db.path(package, version), relative_path)
-        link = self.pattern(package, version, app_name, user=user)
-        if not os.path.islink(link) or os.readlink(link) != target:
-            osextras.ensuredir(os.path.dirname(link))
-            osextras.symlink_force(target, link)
-
-    def install_package(self, package, version, app_name, relative_path,
-                        user=None):
-        if self.user_level:
-            user_db = ClickUser(self.db, user=user)
-        else:
-            assert user is None
-
-        # Remove previous versions if necessary.
-        if self.single_version:
-            for path, p_package, p_version, p_app_name in \
-                    self._previous_entries(user=user):
-                if (p_package == package and p_app_name == app_name and
-                        p_version != version):
-                    osextras.unlink_force(path)
-
-        if self.user_level:
-            with user_db._dropped_privileges():
-                self._install_link(
-                    package, version, app_name, relative_path,
-                    user=user, user_db=user_db)
-        else:
-            self._install_link(package, version, app_name, relative_path)
-        self._run_commands(user=user)
-
-    def remove_package(self, package, version, app_name, user=None):
-        osextras.unlink_force(
-            self.pattern(package, version, app_name, user=user))
-        self._run_commands(user=user)
-
-    def _all_packages(self, user=None):
-        """Return an iterable of all unpacked packages.
-
-        If running a user-level hook, this returns (package, version, user)
-        for the current version of each package registered for each user, or
-        only for a single user if user is not None.
-
-        If running a system-level hook, this returns (package, version,
-        None) for each version of each unpacked package.
-        """
-        if self.user_level:
-            if user is not None:
-                user_db = ClickUser(self.db, user=user)
-                for package, version in user_db.items():
-                    yield package, version, user
-            else:
-                for user_name, user_db in ClickUsers(self.db).items():
-                    if user_name.startswith("@"):
-                        continue
-                    for package, version in user_db.items():
-                        yield package, version, user_name
-        else:
-            for package, version, _, _ in self.db.packages():
-                yield package, version, None
-
-    def _relevant_apps(self, user=None):
-        """Return an iterable of all applications relevant for this hook."""
-        for package, version, user_name in self._all_packages(user=user):
-            manifest = _read_manifest_hooks(self.db, package, version)
-            for app_name, hooks in manifest.items():
-                if self.hook_name in hooks:
-                    yield (
-                        package, version, app_name, user_name,
-                        hooks[self.hook_name])
-
-    def install(self, user=None):
-        for package, version, app_name, user_name, relative_path in (
-                self._relevant_apps(user=user)):
-            self.install_package(
-                package, version, app_name, relative_path, user=user_name)
-
-    def remove(self, user=None):
-        for package, version, app_name, user_name, _ in (
-                self._relevant_apps(user=user)):
-            self.remove_package(package, version, app_name, user=user_name)
-
-    def sync(self, user=None):
-        if self.user_level:
-            user_db = ClickUser(self.db, user=user)
-        else:
-            assert user is None
-
-        seen = set()
-        for package, version, app_name, user_name, relative_path in (
-                self._relevant_apps(user=user)):
-            seen.add((package, version, app_name))
-            if self.user_level:
-                with user_db._dropped_privileges():
-                    self._install_link(
-                        package, version, app_name, relative_path,
-                        user=user_name, user_db=user_db)
-            else:
-                self._install_link(package, version, app_name, relative_path)
-        for path, package, version, app_name in \
-                self._previous_entries(user=user):
-            if (package, version, app_name) not in seen:
-                osextras.unlink_force(path)
-        self._run_commands(user=user)
-
-
-def _app_hooks(hooks):
-    items = set()
-    for app_name in hooks:
-        for hook_name in hooks[app_name]:
-            items.add((app_name, hook_name))
-    return items
-
-
-def package_install_hooks(db, package, old_version, new_version, user=None):
-    """Run hooks following installation or upgrade of a Click package.
-
-    If user is None, only run system-level hooks.  If user is not None, only
-    run user-level hooks for that user.
-    """
-    old_manifest = _read_manifest_hooks(db, package, old_version)
-    new_manifest = _read_manifest_hooks(db, package, new_version)
-
-    # Remove any targets for single-version hooks that were in the old
-    # manifest but not the new one.
-    for app_name, hook_name in sorted(
-            _app_hooks(old_manifest) - _app_hooks(new_manifest)):
-        for hook in ClickHook.open_all(db, hook_name):
-            if hook.user_level != (user is not None):
-                continue
-            if hook.single_version:
-                hook.remove_package(package, old_version, app_name, user=user)
-
-    for app_name, app_hooks in sorted(new_manifest.items()):
-        for hook_name, relative_path in sorted(app_hooks.items()):
-            for hook in ClickHook.open_all(db, hook_name):
-                if hook.user_level != (user is not None):
-                    continue
-                hook.install_package(
-                    package, new_version, app_name, relative_path, user=user)
-
-
-def package_remove_hooks(db, package, old_version, user=None):
-    """Run hooks following removal of a Click package.
-
-    If user is None, only run system-level hooks.  If user is not None, only
-    run user-level hooks for that user.
-    """
-    old_manifest = _read_manifest_hooks(db, package, old_version)
-
-    for app_name, app_hooks in sorted(old_manifest.items()):
-        for hook_name in sorted(app_hooks):
-            for hook in ClickHook.open_all(db, hook_name):
-                if hook.user_level != (user is not None):
-                    continue
-                hook.remove_package(package, old_version, app_name, user=user)
-
-
-def run_system_hooks(db):
-    """Run system-level hooks for all installed packages.
-
-    This is useful when starting up from images with preinstalled packages
-    which may not have had their system-level hooks run properly when
-    building the image.  It is suitable for running at system startup.
-    """
-    db.ensure_ownership()
-    for hook in ClickHook.open_all(db):
-        if not hook.user_level:
-            hook.sync()
-
-
-def run_user_hooks(db, user=None):
-    """Run user-level hooks for all packages registered for a user.
-
-    This is useful to catch up with packages that may have been preinstalled
-    and registered for all users.  It is suitable for running at session
-    startup.
-    """
-    if user is None:
-        user = pwd.getpwuid(os.getuid()).pw_name
-    for hook in ClickHook.open_all(db):
-        if hook.user_level:
-            hook.sync(user=user)
 
=== modified file 'click/install.py'
--- click/install.py	2014-01-22 14:02:33 +0000
+++ click/install.py	2014-03-06 07:04:44 +0000
@@ -43,12 +43,10 @@
 import apt_pkg
 from debian.debfile import DebFile as _DebFile
 from debian.debian_support import Version
+from gi.repository import Click
 
-from click import osextras
-from click.hooks import package_install_hooks
 from click.paths import frameworks_dir, preload_path
 from click.preinst import static_preinst_matches
-from click.user import ClickUser
 from click.versions import spec_version
 
 
@@ -313,12 +311,14 @@
 
     def install(self, path, user=None, all_users=False):
         package_name, package_version = self.audit(path, check_arch=True)
-        package_dir = os.path.join(self.db.overlay, package_name)
+        package_dir = os.path.join(self.db.props.overlay, package_name)
         inst_dir = os.path.join(package_dir, package_version)
-        assert os.path.dirname(os.path.dirname(inst_dir)) == self.db.overlay
+        assert (
+            os.path.dirname(os.path.dirname(inst_dir)) ==
+            self.db.props.overlay)
 
-        self._check_write_permissions(self.db.overlay)
-        root_click = os.path.join(self.db.overlay, ".click")
+        self._check_write_permissions(self.db.props.overlay)
+        root_click = os.path.join(self.db.props.overlay, ".click")
         if not os.path.exists(root_click):
             os.makedirs(root_click)
             if os.geteuid() == 0:
@@ -348,7 +348,7 @@
             if "LD_PRELOAD" in env:
                 preloads.append(env["LD_PRELOAD"])
             env["LD_PRELOAD"] = " ".join(preloads)
-            env["CLICK_BASE_DIR"] = self.db.overlay
+            env["CLICK_BASE_DIR"] = self.db.props.overlay
             env["CLICK_PACKAGE_PATH"] = path
             env["CLICK_PACKAGE_FD"] = str(fd.fileno())
             env.pop("HOME", None)
@@ -379,11 +379,11 @@
                 old_version = None
         else:
             old_version = None
-        package_install_hooks(
+        Click.package_install_hooks(
             self.db, package_name, old_version, package_version)
 
         new_path = os.path.join(package_dir, "current.new")
-        osextras.symlink_force(package_version, new_path)
+        Click.symlink_force(package_version, new_path)
         if os.geteuid() == 0:
             # shutil.chown would be more convenient, but it doesn't support
             # follow_symlinks=False in Python 3.3.
@@ -393,7 +393,10 @@
         os.rename(new_path, current_path)
 
         if user is not None or all_users:
-            registry = ClickUser(self.db, user=user, all_users=all_users)
+            if all_users:
+                registry = Click.User.for_all_users(self.db)
+            else:
+                registry = Click.User.for_user(self.db, name=user)
             registry.set_version(package_name, package_version)
 
         if old_version is not None:
 
=== modified file 'click/osextras.py'
--- click/osextras.py	2013-09-04 15:59:18 +0000
+++ click/osextras.py	2014-03-06 07:04:44 +0000
@@ -13,7 +13,15 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-"""Extra OS-level utility functions."""
+"""Extra OS-level utility functions.
+
+Usually we can instead use the functions exported from
+lib/click/osextras.vala via GObject Introspection.  These pure-Python
+versions are preserved so that they can be used from code that needs to be
+maximally portable: for example, click.build is intended to be usable even
+on systems that lack GObject, as long as they have a reasonably recent
+version of Python.
+"""
 
 __all__ = [
     'ensuredir',
 
=== modified file 'click/paths.py.in'
--- click/paths.py.in	2013-09-03 12:50:11 +0000
+++ click/paths.py.in	2014-03-06 07:04:44 +0000
@@ -17,5 +17,3 @@
 
 preload_path = "@pkglibdir@/libclickpreload.so"
 frameworks_dir = "@pkgdatadir@/frameworks"
-hooks_dir = "@pkgdatadir@/hooks"
-db_dir = "@sysconfdir@/click/databases"
 
=== removed file 'click/query.py'
--- click/query.py	2013-07-23 18:30:48 +0000
+++ click/query.py	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-# Copyright (C) 2013 Canonical Ltd.
-# Author: Colin Watson <[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/>.
-
-"""Query information about installed Click packages."""
-
-from __future__ import print_function
-
-__metaclass__ = type
-__all__ = [
-    'find_package_directory',
-    ]
-
-import os
-
-
-def _walk_up(path):
-    while True:
-        yield path
-        newpath = os.path.dirname(path)
-        if newpath == path:
-            return
-        path = newpath
-
-
-def find_package_directory(path):
-    for directory in _walk_up(os.path.realpath(path)):
-        if os.path.isdir(os.path.join(directory, ".click", "info")):
-            return directory
-            break
-    else:
-        raise Exception("No package directory found for %s" % path)
 
=== added file 'click/tests/Makefile.am'
--- click/tests/Makefile.am	1970-01-01 00:00:00 +0000
+++ click/tests/Makefile.am	2014-03-06 07:04:44 +0000
@@ -0,0 +1,10 @@
+noinst_DATA = preload.gir
+CLEANFILES = $(noinst_DATA)
+
+preload.gir: preload.h
+	PKG_CONFIG_PATH=$(top_builddir)/lib/click g-ir-scanner \
+		-n preload --nsversion 0 -l c \
+		--pkg glib-2.0 --pkg gee-0.8 --pkg click-0.4 \
+		-I$(top_builddir)/lib/click -L$(top_builddir)/lib/click \
+		--accept-unprefixed --warn-all \
+		$< --output $@
 
=== modified file 'click/tests/__init__.py'
--- click/tests/__init__.py	2013-04-10 15:55:06 +0000
+++ click/tests/__init__.py	2014-03-06 07:04:44 +0000
@@ -0,0 +1,39 @@
+from __future__ import print_function
+
+import os
+import sys
+
+from click.tests import config
+
+
+def _append_env_path(envname, value):
+    if envname in os.environ:
+        if value in os.environ[envname].split(":"):
+            return False
+        os.environ[envname] = "%s:%s" % (os.environ[envname], value)
+    else:
+        os.environ[envname] = value
+    return True
+
+
+# Don't do any of this in interactive mode.
+if not hasattr(sys, "ps1"):
+    _lib_click_dir = os.path.join(config.abs_top_builddir, "lib", "click")
+    changed = False
+    if _append_env_path(
+            "LD_LIBRARY_PATH", os.path.join(_lib_click_dir, ".libs")):
+        changed = True
+    if _append_env_path("GI_TYPELIB_PATH", _lib_click_dir):
+        changed = True
+    if changed:
+        # We have to re-exec ourselves to get the dynamic loader to pick up
+        # the new value of LD_LIBRARY_PATH.
+        if "-m unittest" in sys.argv[0]:
+            # unittest does horrible things to sys.argv in the name of
+            # "usefulness", making the re-exec more painful than it needs to
+            # be.
+            os.execvp(
+                sys.executable, [sys.executable, "-m", "unittest"] + sys.argv[1:])
+        else:
+            os.execvp(sys.executable, [sys.executable] + sys.argv)
+        os._exit(1)
 
=== added file 'click/tests/config.py.in'
--- click/tests/config.py.in	1970-01-01 00:00:00 +0000
+++ click/tests/config.py.in	2014-03-06 07:04:44 +0000
@@ -0,0 +1,20 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Colin Watson <[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/>.
+
+abs_top_builddir = "@abs_top_builddir@"
+STAT_OFFSET_UID = @STAT_OFFSET_UID@
+STAT_OFFSET_GID = @STAT_OFFSET_GID@
+STAT64_OFFSET_UID = @STAT64_OFFSET_UID@
+STAT64_OFFSET_GID = @STAT64_OFFSET_GID@
 
=== added file 'click/tests/gimock.py'
--- click/tests/gimock.py	1970-01-01 00:00:00 +0000
+++ click/tests/gimock.py	2014-03-06 07:04:44 +0000
@@ -0,0 +1,499 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Colin Watson <[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/>.
+
+"""Mock function support based on GObject Introspection.
+
+(Note to reviewers: I expect to rewrite this from scratch on my own time as
+a more generalised set of Python modules for unit testing of C code,
+although using similar core ideas.  This is a first draft for the purpose of
+getting Click's test suite to work expediently, rather than an interface I'm
+prepared to commit to long-term.)
+
+Python is a versatile and concise language for writing tests, and GObject
+Introspection (GI) makes it straightforward (often trivial) to bind native
+code into Python.  However, writing tests for native code quickly runs into
+the problem of how to build mock functions.  You might reasonably have code
+that calls chown(), for instance, and want to test how it's called rather
+than worrying about setting up a fakeroot-type environment where chown()
+will work.  The obvious solution is to use `LD_PRELOAD` wrappers, but there
+are various problems to overcome in practice:
+
+ * You can only set up a new `LD_PRELOAD` by going through the run-time
+   linker; you can't just set it for a single in-process test case.
+ * Generating the preloaded wrapper involves a fair bit of boilerplate code.
+ * Having to write per-test mock code in C is inconvenient, and makes it
+   difficult to get information back out of the mock (such as "how often was
+   this function called, and with what arguments?").
+
+The first problem can be solved by a decorator that knows how to run
+individual tests in a subprocess.  This is made somewhat more inconvenient
+by the fact that there is no way for a context manager's `__enter__` method
+to avoid executing the context-managed block other than by throwing an
+exception, which makes it hard to silently avoid executing the test case in
+the parent process, but we can work around this at the cost of an extra line
+of code per invocation.
+
+For the rest, a combination of GI itself and ctypes can help.  We can use GI
+to keep track of argument and return types of the mocked C functions in a
+reasonably sane way, by parsing header files.  We're operating in the other
+direction from how GI is normally used, so PyGObject can't deal with
+bridging the two calling conventions for us.  ctypes can: but we still need
+to be careful!  We have to construct the callback functions in the child
+process, ensure that we keep references to them, and inject function
+pointers into the preloaded library via specially-named helper functions;
+until those function pointers are set up we must make sure to call the libc
+functions instead (since some of them might be called during Python
+startup).
+
+The combination of all of this allows us to bridge C functions somewhat
+transparently into Python.  This lets you supply a Python function or method
+as the mock replacement for a C library function, making it much simpler to
+record state.
+
+It's still not perfect:
+
+ * We're using GI in an upside-down kind of way, and we specifically need
+   GIR files rather than typelibs so that we can extract the original C
+   type, so some fiddling is required for each new function you want to
+   mock.
+
+ * The subprocess arrangements are unavoidably slow and it's possible that
+   they may cause problems with some test runners.
+
+ * Some C functions (such as `stat`) tend to have multiple underlying entry
+   points in the C library which must be preloaded independently.
+
+ * You have to be careful about how your libraries are linked, because `ld
+   -Wl,-Bsymbolic-functions` prevents `LD_PRELOAD` working for intra-library
+   calls.
+
+ * `ctypes should return composite types from callbacks
+   <http://bugs.python.org/issue5710>`_.  The least awful approach for now
+   seems to be to construct the composite type in question, stash a
+   reference to it forever, and then return a pointer to it as a void *; we
+   can only get away with this because tests are by nature relatively
+   short-lived.
+
+ * The ctypes module's handling of 64-bit pointers is basically just awful.
+   The right answer is probably to use a different callback-generation
+   framework entirely (maybe extending PyGObject so that we can get at the
+   pieces we need), but I've hacked around it for now.
+
+ * It doesn't appear to be possible to install mock replacements for
+   functions that are called directly from Python code using their GI
+   wrappers.  You can work around this by simply patching the GI wrapper
+   instead, using `mock.patch`.
+
+I think the benefits, in terms of local clarity of tests, are worth the
+downsides.
+"""
+
+from __future__ import print_function
+
+__metaclass__ = type
+__all__ = ['GIMockTestCase']
+
+
+import contextlib
+import ctypes
+import fcntl
+from functools import partial
+import os
+import pickle
+import shutil
+import subprocess
+import sys
+import tempfile
+from textwrap import dedent
+import traceback
+import unittest
+try:
+    from unittest import mock
+except ImportError:
+    import mock
+try:
+    import xml.etree.cElementTree as etree
+except ImportError:
+    import xml.etree.ElementTree as etree
+
+from click.tests.gimock_types import Stat, Stat64
+
+
+# Borrowed from giscanner.girparser.
+CORE_NS = "http://www.gtk.org/introspection/core/1.0"
+C_NS = "http://www.gtk.org/introspection/c/1.0"
+GLIB_NS = "http://www.gtk.org/introspection/glib/1.0"
+
+
+def _corens(tag):
+    return '{%s}%s' % (CORE_NS, tag)
+
+
+def _glibns(tag):
+    return '{%s}%s' % (GLIB_NS, tag)
+
+
+def _cns(tag):
+    return '{%s}%s' % (C_NS, tag)
+
+
+# Override some c:type annotations that g-ir-scanner gets a bit wrong.
+_c_type_override = {
+    "passwd*": "struct passwd*",
+    "stat*": "struct stat*",
+    "stat64*": "struct stat64*",
+    }
+
+
+# Mapping of GI type name -> ctypes type.
+_typemap = {
+    "GError**": ctypes.c_void_p,
+    "gboolean": ctypes.c_bool,
+    "gint": ctypes.c_int,
+    "gint*": ctypes.POINTER(ctypes.c_int),
+    "gint32": ctypes.c_int32,
+    "gpointer": ctypes.c_void_p,
+    "guint": ctypes.c_uint,
+    "guint8**": ctypes.POINTER(ctypes.POINTER(ctypes.c_uint8)),
+    "guint32": ctypes.c_uint32,
+    "none": None,
+    "utf8": ctypes.c_char_p,
+    "utf8*": ctypes.POINTER(ctypes.c_char_p),
+    }
+
+
+class GIMockTestCase(unittest.TestCase):
+    def setUp(self):
+        super(GIMockTestCase, self).setUp()
+        self._gimock_temp_dir = tempfile.mkdtemp(prefix="gimock")
+        self.addCleanup(shutil.rmtree, self._gimock_temp_dir)
+        self._preload_func_refs = []
+        self._composite_refs = []
+        self._delegate_funcs = {}
+
+    def tearDown(self):
+        self._preload_func_refs = []
+        self._composite_refs = []
+        self._delegate_funcs = {}
+
+    def _gir_get_type(self, obj):
+        ret = {}
+        arrayinfo = obj.find(_corens("array"))
+        if arrayinfo is not None:
+            typeinfo = arrayinfo.find(_corens("type"))
+            raw_ctype = arrayinfo.get(_cns("type"))
+        else:
+            typeinfo = obj.find(_corens("type"))
+            raw_ctype = typeinfo.get(_cns("type"))
+        gi_type = typeinfo.get("name")
+        if obj.get("direction", "in") == "out":
+            gi_type += "*"
+        if arrayinfo is not None:
+            gi_type += "*"
+        ret["gi"] = gi_type
+        ret["c"] = _c_type_override.get(raw_ctype, raw_ctype)
+        return ret
+
+    def _parse_gir(self, path):
+        # A very, very crude GIR parser.  We might have used
+        # giscanner.girparser, but it's not importable in Python 3 at the
+        # moment.
+        tree = etree.parse(path)
+        root = tree.getroot()
+        assert root.tag == _corens("repository")
+        assert root.get("version") == "1.2"
+        ns = root.find(_corens("namespace"))
+        assert ns is not None
+        funcs = {}
+        for func in ns.findall(_corens("function")):
+            name = func.get(_cns("identifier"))
+            # g-ir-scanner skips identifiers starting with "__", which we
+            # need in order to mock stat effectively.  Work around this.
+            name = name.replace("under_under_", "__")
+            headers = None
+            for attr in func.findall(_corens("attribute")):
+                if attr.get("name") == "headers":
+                    headers = attr.get("value")
+                    break
+            rv = func.find(_corens("return-value"))
+            assert rv is not None
+            params = []
+            paramnode = func.find(_corens("parameters"))
+            if paramnode is not None:
+                for param in paramnode.findall(_corens("parameter")):
+                    params.append({
+                        "name": param.get("name"),
+                        "type": self._gir_get_type(param),
+                        })
+            if func.get("throws", "0") == "1":
+                params.append({
+                    "name": "error",
+                    "type": { "gi": "GError**", "c": "GError**" },
+                    })
+            funcs[name] = {
+                "name": name,
+                "headers": headers,
+                "rv": self._gir_get_type(rv),
+                "params": params,
+                }
+        return funcs
+
+    def _ctypes_type(self, gi_type):
+        return _typemap[gi_type["gi"]]
+
+    def make_preloads(self, preloads):
+        rpreloads = []
+        std_headers = set([
+            "dlfcn.h",
+            # Not strictly needed, but convenient for ad-hoc debugging.
+            "stdio.h",
+            "stdint.h",
+            "stdlib.h",
+            "sys/types.h",
+            "unistd.h",
+            ])
+        preload_headers = set()
+        funcs = self._parse_gir("click/tests/preload.gir")
+        for name, func in preloads.items():
+            info = funcs[name]
+            rpreloads.append([info, func])
+            headers = info["headers"]
+            if headers is not None:
+                preload_headers.update(headers.split(","))
+        if "GIMOCK_SUBPROCESS" in os.environ:
+            return None, rpreloads
+        preloads_dir = os.path.join(self._gimock_temp_dir, "_preloads")
+        os.makedirs(preloads_dir)
+        c_path = os.path.join(preloads_dir, "gimockpreload.c")
+        with open(c_path, "w") as c:
+            print("#define _GNU_SOURCE", file=c)
+            for header in sorted(std_headers | preload_headers):
+                print("#include <%s>" % header, file=c)
+            print(file=c)
+            for info, _ in rpreloads:
+                conv = {}
+                conv["name"] = info["name"]
+                argtypes = [p["type"]["c"] for p in info["params"]]
+                argnames = [p["name"] for p in info["params"]]
+                conv["ret"] = info["rv"]["c"]
+                conv["bareproto"] = ", ".join(argtypes)
+                conv["proto"] = ", ".join(
+                    "%s %s" % pair for pair in zip(argtypes, argnames))
+                conv["args"] = ", ".join(argnames)
+                # The delegation scheme used here is needed because trying
+                # to pass pointers back and forward through ctypes is a
+                # recipe for having them truncated to 32 bits at the drop of
+                # a hat.  This approach is less obvious but much safer.
+                print(dedent("""\
+                    typedef %(ret)s preloadtype_%(name)s (%(bareproto)s);
+                    preloadtype_%(name)s *ctypes_%(name)s = (void *) 0;
+                    preloadtype_%(name)s *real_%(name)s = (void *) 0;
+                    static volatile int delegate_%(name)s = 0;
+
+                    extern void _gimock_init_%(name)s (preloadtype_%(name)s *f)
+                    {
+                        ctypes_%(name)s = f;
+                        if (! real_%(name)s) {
+                            /* Retry lookup in case the symbol wasn't
+                             * resolvable until the program under test was
+                             * loaded.
+                             */
+                            dlerror ();
+                            real_%(name)s = dlsym (RTLD_NEXT, \"%(name)s\");
+                            if (dlerror ()) _exit (1);
+                        }
+                    }
+                    """) % conv, file=c)
+                if conv["ret"] == "void":
+                    print(dedent("""\
+                        void %(name)s (%(proto)s)
+                        {
+                            if (ctypes_%(name)s) {
+                                delegate_%(name)s = 0;
+                                (*ctypes_%(name)s) (%(args)s);
+                                if (! delegate_%(name)s)
+                                    return;
+                            }
+                            (*real_%(name)s) (%(args)s);
+                        }
+                        """) % conv, file=c)
+                else:
+                    print(dedent("""\
+                        %(ret)s %(name)s (%(proto)s)
+                        {
+                            if (ctypes_%(name)s) {
+                                %(ret)s ret;
+                                delegate_%(name)s = 0;
+                                ret = (*ctypes_%(name)s) (%(args)s);
+                                if (! delegate_%(name)s)
+                                    return ret;
+                            }
+                            return (*real_%(name)s) (%(args)s);
+                        }
+                        """) % conv, file=c)
+                print(dedent("""\
+                    extern void _gimock_delegate_%(name)s (void)
+                    {
+                        delegate_%(name)s = 1;
+                    }
+                    """) % conv, file=c)
+            print(dedent("""\
+                static void __attribute__ ((constructor))
+                gimockpreload_init (void)
+                {
+                    dlerror ();
+                """), file=c)
+            for info, _ in rpreloads:
+                name = info["name"]
+                print("    real_%s = dlsym (RTLD_NEXT, \"%s\");" %
+                      (name, name), file=c)
+                print("    if (dlerror ()) _exit (1);", file=c)
+            print("}", file=c)
+        if "GIMOCK_PRELOAD_DEBUG" in os.environ:
+            with open(c_path) as c:
+                print(c.read())
+        # TODO: Use libtool or similar rather than hardcoding gcc invocation.
+        lib_path = os.path.join(preloads_dir, "libgimockpreload.so")
+        cflags = subprocess.check_output([
+            "pkg-config", "--cflags", "glib-2.0", "gee-0.8"],
+            universal_newlines=True).rstrip("\n").split()
+        subprocess.check_call([
+            "gcc", "-O0", "-g", "-shared", "-fPIC", "-DPIC", "-I", "lib/click",
+            ] + cflags + [
+            "-Wl,-soname", "-Wl,libgimockpreload.so",
+            c_path, "-ldl", "-o", lib_path,
+            ])
+        return lib_path, rpreloads
+
+    # Use as:
+    #   with self.run_in_subprocess("func", ...) as (enter, preloads):
+    #       enter()
+    #       # test case body; preloads["func"] will be a mock.MagicMock
+    #       # instance
+    @contextlib.contextmanager
+    def run_in_subprocess(self, *patches):
+        preloads = {}
+        for patch in patches:
+            preloads[patch] = mock.MagicMock()
+        if preloads:
+            lib_path, rpreloads = self.make_preloads(preloads)
+        else:
+            lib_path, rpreloads = None, None
+
+        class ParentProcess(Exception):
+            pass
+
+        def helper(lib_path, rpreloads):
+            if "GIMOCK_SUBPROCESS" in os.environ:
+                del os.environ["LD_PRELOAD"]
+                preload_lib = ctypes.cdll.LoadLibrary(lib_path)
+                delegate_cfunctype = ctypes.CFUNCTYPE(None)
+                for info, func in rpreloads:
+                    signature = [info["rv"]] + [
+                        p["type"] for p in info["params"]]
+                    signature = [self._ctypes_type(t) for t in signature]
+                    cfunctype = ctypes.CFUNCTYPE(*signature)
+                    init = getattr(
+                        preload_lib, "_gimock_init_%s" % info["name"])
+                    cfunc = cfunctype(func)
+                    self._preload_func_refs.append(cfunc)
+                    init(cfunc)
+                    delegate = getattr(
+                        preload_lib, "_gimock_delegate_%s" % info["name"])
+                    self._delegate_funcs[info["name"]] = delegate_cfunctype(
+                        delegate)
+                return
+            rfd, wfd = os.pipe()
+            # It would be cleaner to use subprocess.Popen(pass_fds=[wfd]), but
+            # that isn't available in Python 2.7.
+            if hasattr(os, "set_inheritable"):
+                os.set_inheritable(wfd, True)
+            else:
+                fcntl.fcntl(rfd, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
+            args = [
+                sys.executable, "-m", "unittest",
+                "%s.%s.%s" % (
+                    self.__class__.__module__, self.__class__.__name__,
+                    self._testMethodName)]
+            env = os.environ.copy()
+            env["GIMOCK_SUBPROCESS"] = str(wfd)
+            if lib_path is not None:
+                env["LD_PRELOAD"] = lib_path
+            subp = subprocess.Popen(args, close_fds=False, env=env)
+            os.close(wfd)
+            reader = os.fdopen(rfd, "rb")
+            subp.communicate()
+            exctype = pickle.load(reader)
+            if exctype is not None and issubclass(exctype, AssertionError):
+                raise AssertionError("Subprocess failed a test!")
+            elif exctype is not None or subp.returncode != 0:
+                raise Exception("Subprocess returned an error!")
+            reader.close()
+            raise ParentProcess()
+
+        try:
+            yield partial(helper, lib_path, rpreloads), preloads
+            if "GIMOCK_SUBPROCESS" in os.environ:
+                wfd = int(os.environ["GIMOCK_SUBPROCESS"])
+                writer = os.fdopen(wfd, "wb")
+                pickle.dump(None, writer)
+                writer.flush()
+                os._exit(0)
+        except ParentProcess:
+            pass
+        except Exception as e:
+            if "GIMOCK_SUBPROCESS" in os.environ:
+                wfd = int(os.environ["GIMOCK_SUBPROCESS"])
+                writer = os.fdopen(wfd, "wb")
+                # It would be better to use tblib to pickle the traceback so
+                # that we can re-raise it properly from the parent process.
+                # Until that's packaged and available to us, just print the
+                # traceback and send the exception type.
+                print()
+                traceback.print_exc()
+                pickle.dump(type(e), writer)
+                writer.flush()
+                os._exit(1)
+            else:
+                raise
+
+    def make_pointer(self, composite):
+        # Store a reference to a composite type and return a pointer to it,
+        # working around http://bugs.python.org/issue5710.
+        self._composite_refs.append(composite)
+        return ctypes.addressof(composite)
+
+    def make_string(self, s):
+        # As make_pointer, but for a string.
+        copied = ctypes.create_string_buffer(s.encode())
+        self._composite_refs.append(copied)
+        return ctypes.addressof(copied)
+
+    def convert_pointer(self, composite_type, address):
+        # Return a ctypes composite type instance at a given address.
+        return composite_type.from_address(address)
+
+    def convert_stat_pointer(self, name, address):
+        # As convert_pointer, but for a "struct stat *" or "struct stat64 *"
+        # depending on the wrapped function name.
+        stat_type = {"__xstat": Stat, "__xstat64": Stat64}
+        return self.convert_pointer(stat_type[name], address)
+
+    def delegate_to_original(self, name):
+        # Cause the wrapper function to delegate to the original version
+        # after the callback returns.  (Note that the callback still needs
+        # to return something type-compatible with the declared result type,
+        # although the return value will otherwise be ignored.)
+        self._delegate_funcs[name]()
 
=== added file 'click/tests/gimock_types.py'
--- click/tests/gimock_types.py	1970-01-01 00:00:00 +0000
+++ click/tests/gimock_types.py	2014-03-06 07:04:44 +0000
@@ -0,0 +1,89 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Colin Watson <[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/>.
+
+"""A collection of variously hacky ctypes definitions for use with gimock."""
+
+import ctypes
+
+from click.tests.config import (
+    STAT_OFFSET_GID,
+    STAT_OFFSET_UID,
+    STAT64_OFFSET_GID,
+    STAT64_OFFSET_UID,
+    )
+
+
+class Passwd(ctypes.Structure):
+    _fields_ = [
+        ("pw_name", ctypes.c_char_p),
+        ("pw_passwd", ctypes.c_char_p),
+        ("pw_uid", ctypes.c_uint32),
+        ("pw_gid", ctypes.c_uint32),
+        ("pw_gecos", ctypes.c_char_p),
+        ("pw_dir", ctypes.c_char_p),
+        ("pw_shell", ctypes.c_char_p),
+        ]
+
+
+# TODO: This is pretty awful.  The layout of "struct stat" is complicated
+# enough that we have to use offsetof() in configure to pick out the fields
+# we care about.  Fortunately, we only care about a couple of fields, and
+# since this is an output parameter it doesn't matter if our structure is
+# too short (if we cared about this then we could use AC_CHECK_SIZEOF to
+# figure it out).
+class Stat(ctypes.Structure):
+    _pack_ = 1
+    _fields_ = []
+    _fields_.append(
+        ("pad0", ctypes.c_ubyte * min(STAT_OFFSET_UID, STAT_OFFSET_GID)))
+    if STAT_OFFSET_UID < STAT_OFFSET_GID:
+        _fields_.append(("st_uid", ctypes.c_uint32))
+        pad = (STAT_OFFSET_GID - STAT_OFFSET_UID -
+               ctypes.sizeof(ctypes.c_uint32))
+        assert pad >= 0
+        if pad > 0:
+            _fields_.append(("pad1", ctypes.c_ubyte * pad))
+        _fields_.append(("st_gid", ctypes.c_uint32))
+    else:
+        _fields_.append(("st_gid", ctypes.c_uint32))
+        pad = (STAT_OFFSET_UID - STAT_OFFSET_GID -
+               ctypes.sizeof(ctypes.c_uint32))
+        assert pad >= 0
+        if pad > 0:
+            _fields_.append(("pad1", ctypes.c_ubyte * pad))
+        _fields_.append(("st_uid", ctypes.c_uint32))
+
+
+class Stat64(ctypes.Structure):
+    _pack_ = 1
+    _fields_ = []
+    _fields_.append(
+        ("pad0", ctypes.c_ubyte * min(STAT64_OFFSET_UID, STAT64_OFFSET_GID)))
+    if STAT64_OFFSET_UID < STAT64_OFFSET_GID:
+        _fields_.append(("st_uid", ctypes.c_uint32))
+        pad = (STAT64_OFFSET_GID - STAT64_OFFSET_UID -
+               ctypes.sizeof(ctypes.c_uint32))
+        assert pad >= 0
+        if pad > 0:
+            _fields_.append(("pad1", ctypes.c_ubyte * pad))
+        _fields_.append(("st_gid", ctypes.c_uint32))
+    else:
+        _fields_.append(("st_gid", ctypes.c_uint32))
+        pad = (STAT64_OFFSET_UID - STAT64_OFFSET_GID -
+               ctypes.sizeof(ctypes.c_uint32))
+        assert pad >= 0
+        if pad > 0:
+            _fields_.append(("pad1", ctypes.c_ubyte * pad))
+        _fields_.append(("st_uid", ctypes.c_uint32))
 
=== modified file 'click/tests/helpers.py'
--- click/tests/helpers.py	2014-03-01 23:28:24 +0000
+++ click/tests/helpers.py	2014-03-06 07:04:44 +0000
@@ -39,10 +39,12 @@
 except ImportError:
     import mock
 
-from click import osextras
-
-
-class TestCase(unittest.TestCase):
+from gi.repository import Click, GLib
+
+from click.tests import gimock
+
+
+class TestCase(gimock.GIMockTestCase):
     def setUp(self):
         super(TestCase, self).setUp()
         self.temp_dir = None
@@ -74,6 +76,33 @@
     if not hasattr(unittest.TestCase, 'assertRaisesRegex'):
         assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
 
+    def assertRaisesGError(self, domain_name, code, callableObj,
+                           *args, **kwargs):
+        with self.assertRaises(GLib.GError) as cm:
+            callableObj(*args, **kwargs)
+        self.assertEqual(domain_name, cm.exception.domain)
+        self.assertEqual(code, cm.exception.code)
+
+    def assertRaisesFileError(self, code, callableObj, *args, **kwargs):
+        self.assertRaisesGError(
+            "g-file-error-quark", code, callableObj, *args, **kwargs)
+
+    def assertRaisesDatabaseError(self, code, callableObj, *args, **kwargs):
+        self.assertRaisesGError(
+            "click_database_error-quark", code, callableObj, *args, **kwargs)
+
+    def assertRaisesHooksError(self, code, callableObj, *args, **kwargs):
+        self.assertRaisesGError(
+            "click_hooks_error-quark", code, callableObj, *args, **kwargs)
+
+    def assertRaisesQueryError(self, code, callableObj, *args, **kwargs):
+        self.assertRaisesGError(
+            "click_query_error-quark", code, callableObj, *args, **kwargs)
+
+    def assertRaisesUserError(self, code, callableObj, *args, **kwargs):
+        self.assertRaisesGError(
+            "click_user_error-quark", code, callableObj, *args, **kwargs)
+
 
 if not hasattr(mock, "call"):
     # mock 0.7.2, the version in Ubuntu 12.04 LTS, lacks mock.ANY and
@@ -228,14 +257,14 @@
 
 @contextlib.contextmanager
 def mkfile(path, mode="w"):
-    osextras.ensuredir(os.path.dirname(path))
+    Click.ensuredir(os.path.dirname(path))
     with open(path, mode) as f:
         yield f
 
 
 @contextlib.contextmanager
 def mkfile_utf8(path, mode="w"):
-    osextras.ensuredir(os.path.dirname(path))
+    Click.ensuredir(os.path.dirname(path))
     if sys.version < "3":
         import codecs
         with codecs.open(path, mode, "UTF-8") as f:
 
=== added file 'click/tests/preload.h'
--- click/tests/preload.h	1970-01-01 00:00:00 +0000
+++ click/tests/preload.h	2014-03-06 07:04:44 +0000
@@ -0,0 +1,110 @@
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <glib.h>
+
+#include "click.h"
+
+/**
+ * chown:
+ *
+ * Attributes: (headers unistd.h)
+ */
+extern int chown (const char *file, uid_t owner, gid_t group);
+
+/* Workaround for g-ir-scanner not picking up the type properly: mode_t is
+ * uint32_t on all glibc platforms.
+ */
+/**
+ * mkdir:
+ * @mode: (type guint32)
+ *
+ * Attributes: (headers sys/stat.h,sys/types.h)
+ */
+extern int mkdir (const char *pathname, mode_t mode);
+
+/**
+ * getpwnam:
+ *
+ * Attributes: (headers sys/types.h,pwd.h)
+ * Returns: (transfer none):
+ */
+extern struct passwd *getpwnam (const char *name);
+
+/**
+ * under_under_xstat:
+ *
+ * Attributes: (headers sys/types.h,sys/stat.h,unistd.h)
+ */
+extern int under_under_xstat (int ver, const char *pathname, struct stat *buf);
+
+/**
+ * under_under_xstat64:
+ *
+ * Attributes: (headers sys/types.h,sys/stat.h,unistd.h)
+ */
+extern int under_under_xstat64 (int ver, const char *pathname, struct stat64 *buf);
+
+const gchar *g_get_user_name (void);
+
+/**
+ * g_spawn_sync:
+ * @argv: (array zero-terminated=1):
+ * @envp: (array zero-terminated=1):
+ * @flags: (type gint)
+ * @child_setup: (type gpointer)
+ * @standard_output: (out) (array zero-terminated=1) (element-type guint8):
+ * @standard_error: (out) (array zero-terminated=1) (element-type guint8):
+ * @exit_status: (out):
+ *
+ * Attributes: (headers glib.h)
+ */
+gboolean g_spawn_sync         (const gchar          *working_directory,
+                               gchar               **argv,
+                               gchar               **envp,
+                               GSpawnFlags           flags,
+                               GSpawnChildSetupFunc  child_setup,
+                               gpointer              user_data,
+                               gchar               **standard_output,
+                               gchar               **standard_error,
+                               gint                 *exit_status,
+                               GError              **error);
+
+/**
+ * click_find_on_path:
+ *
+ * Attributes: (headers glib.h)
+ */
+gboolean click_find_on_path (const gchar *command);
+
+/**
+ * click_get_db_dir:
+ *
+ * Attributes: (headers glib.h)
+ */
+gchar *click_get_db_dir (void);
+
+/**
+ * click_get_hooks_dir:
+ *
+ * Attributes: (headers glib.h)
+ */
+gchar *click_get_hooks_dir (void);
+
+/**
+ * click_get_user_home:
+ *
+ * Attributes: (headers glib.h)
+ */
+gchar *click_get_user_home (const gchar *user_name);
+
+/**
+ * click_package_install_hooks:
+ * @db: (type gpointer)
+ *
+ * Attributes: (headers glib.h,click.h)
+ */
+void click_package_install_hooks (ClickDB *db, const gchar *package,
+				  const gchar *old_version,
+				  const gchar *new_version,
+				  const gchar *user_name, GError **error);
 
=== modified file 'click/tests/test_database.py'
--- click/tests/test_database.py	2013-12-10 14:33:19 +0000
+++ click/tests/test_database.py	2014-03-06 07:04:44 +0000
@@ -24,45 +24,46 @@
     ]
 
 
+from functools import partial
+from itertools import takewhile
 import json
 import os
 
-from click.database import ClickDB
-from click.tests.helpers import TestCase, mkfile, mock, touch
-
-
-class MockPasswd:
-    def __init__(self, pw_uid, pw_gid):
-        self.pw_uid = pw_uid
-        self.pw_gid = pw_gid
-
-
-class MockStatResult:
-    original_stat = os.stat
-
-    def __init__(self, path, **override):
-        self.st = self.original_stat(path)
-        self.override = override
-
-    def __getattr__(self, name):
-        if name in self.override:
-            return self.override[name]
-        else:
-            return getattr(self.st, name)
+from gi.repository import Click
+
+from click.tests.gimock_types import Passwd
+from click.tests.helpers import TestCase, mkfile, touch
 
 
 class TestClickSingleDB(TestCase):
     def setUp(self):
         super(TestClickSingleDB, self).setUp()
         self.use_temp_dir()
-        self.master_db = ClickDB(extra_root=self.temp_dir, use_system=False)
-        self.db = self.master_db._db[-1]
+        self.master_db = Click.DB()
+        self.master_db.add(self.temp_dir)
+        self.db = self.master_db.get(self.master_db.props.size - 1)
+        self.spawn_calls = []
+
+    def g_spawn_sync_side_effect(self, status_map, working_directory, argv,
+                                 envp, flags, child_setup, user_data,
+                                 standard_output, standard_error, exit_status,
+                                 error):
+        self.spawn_calls.append(list(takewhile(lambda x: x is not None, argv)))
+        if argv[0] in status_map:
+            exit_status[0] = status_map[argv[0]]
+        else:
+            self.delegate_to_original("g_spawn_sync")
+        return 0
+
+    def _installed_packages_tuplify(self, ip):
+        return [(p.props.package, p.props.version, p.props.path) for p in ip]
 
     def test_path(self):
         path = os.path.join(self.temp_dir, "a", "1.0")
         os.makedirs(path)
-        self.assertEqual(path, self.db.path("a", "1.0"))
-        self.assertRaises(KeyError, self.db.path, "a", "1.1")
+        self.assertEqual(path, self.db.get_path("a", "1.0"))
+        self.assertRaisesDatabaseError(
+            Click.DatabaseError.DOES_NOT_EXIST, self.db.get_path, "a", "1.1")
 
     def test_packages_current(self):
         os.makedirs(os.path.join(self.temp_dir, "a", "1.0"))
@@ -76,7 +77,8 @@
         self.assertEqual([
             ("a", "1.1", a_current),
             ("b", "0.1", b_current),
-        ], list(self.db.packages()))
+        ], self._installed_packages_tuplify(
+            self.db.get_packages(all_versions=False)))
 
     def test_packages_all(self):
         os.makedirs(os.path.join(self.temp_dir, "a", "1.0"))
@@ -90,120 +92,145 @@
             ("a", "1.1", os.path.join(self.temp_dir, "a", "1.1")),
             ("b", "0.1", os.path.join(self.temp_dir, "b", "0.1")),
             ("c", "2.0", os.path.join(self.temp_dir, "c", "2.0")),
-        ], list(self.db.packages(all_versions=True)))
-
-    @mock.patch("subprocess.call")
-    def test_app_running(self, mock_call):
-        mock_call.return_value = 0
-        self.assertTrue(self.db._app_running("foo", "bar", "1.0"))
-        mock_call.assert_called_once_with(
-            ["upstart-app-pid", "foo_bar_1.0"], stdout=mock.ANY)
-        mock_call.return_value = 1
-        self.assertFalse(self.db._app_running("foo", "bar", "1.0"))
-
-    @mock.patch("click.osextras.find_on_path")
-    @mock.patch("subprocess.call")
-    def test_any_app_running(self, mock_call, mock_find_on_path):
-        manifest_path = os.path.join(
-            self.temp_dir, "a", "1.0", ".click", "info", "a.manifest")
-        with mkfile(manifest_path) as manifest:
-            json.dump({"hooks": {"a-app": {}}}, manifest)
-        mock_call.return_value = 0
-        mock_find_on_path.return_value = False
-        self.assertFalse(self.db._any_app_running("a", "1.0"))
-        mock_find_on_path.return_value = True
-        self.assertTrue(self.db._any_app_running("a", "1.0"))
-        mock_call.assert_called_once_with(
-            ["upstart-app-pid", "a_a-app_1.0"], stdout=mock.ANY)
-        mock_call.return_value = 1
-        self.assertFalse(self.db._any_app_running("a", "1.0"))
-
-    @mock.patch("click.osextras.find_on_path")
-    @mock.patch("subprocess.call")
-    def test_maybe_remove_registered(self, mock_call, mock_find_on_path):
-        version_path = os.path.join(self.temp_dir, "a", "1.0")
-        manifest_path = os.path.join(
-            version_path, ".click", "info", "a.manifest")
-        with mkfile(manifest_path) as manifest:
-            json.dump({"hooks": {"a-app": {}}}, manifest)
-        user_path = os.path.join(
-            self.temp_dir, ".click", "users", "test-user", "a")
-        os.makedirs(os.path.dirname(user_path))
-        os.symlink(version_path, user_path)
-        mock_call.return_value = 0
-        mock_find_on_path.return_value = True
-        self.db.maybe_remove("a", "1.0")
-        self.assertTrue(os.path.exists(version_path))
-        self.assertTrue(os.path.exists(user_path))
-
-    @mock.patch("click.osextras.find_on_path")
-    @mock.patch("subprocess.call")
-    def test_maybe_remove_running(self, mock_call, mock_find_on_path):
-        version_path = os.path.join(self.temp_dir, "a", "1.0")
-        manifest_path = os.path.join(
-            version_path, ".click", "info", "a.manifest")
-        with mkfile(manifest_path) as manifest:
-            json.dump({"hooks": {"a-app": {}}}, manifest)
-        mock_call.return_value = 0
-        mock_find_on_path.return_value = True
-        self.db.maybe_remove("a", "1.0")
-        gcinuse_path = os.path.join(
-            self.temp_dir, ".click", "users", "@gcinuse", "a")
-        self.assertTrue(os.path.islink(gcinuse_path))
-        self.assertEqual(version_path, os.readlink(gcinuse_path))
-        self.assertTrue(os.path.exists(version_path))
-        self.db.maybe_remove("a", "1.0")
-        self.assertTrue(os.path.islink(gcinuse_path))
-        self.assertEqual(version_path, os.readlink(gcinuse_path))
-        self.assertTrue(os.path.exists(version_path))
-
-    @mock.patch("click.osextras.find_on_path")
-    @mock.patch("subprocess.call")
-    def test_maybe_remove_not_running(self, mock_call, mock_find_on_path):
-        version_path = os.path.join(self.temp_dir, "a", "1.0")
-        manifest_path = os.path.join(
-            version_path, ".click", "info", "a.manifest")
-        with mkfile(manifest_path) as manifest:
-            json.dump({"hooks": {"a-app": {}}}, manifest)
-        current_path = os.path.join(self.temp_dir, "a", "current")
-        os.symlink("1.0", current_path)
-        mock_call.return_value = 1
-        mock_find_on_path.return_value = True
-        self.db.maybe_remove("a", "1.0")
-        gcinuse_path = os.path.join(
-            self.temp_dir, ".click", "users", "@gcinuse", "a")
-        self.assertFalse(os.path.islink(gcinuse_path))
-        self.assertFalse(os.path.exists(os.path.join(self.temp_dir, "a")))
-
-    @mock.patch("click.osextras.find_on_path")
-    @mock.patch("subprocess.call")
-    def test_gc(self, mock_call, mock_find_on_path):
-        a_path = os.path.join(self.temp_dir, "a", "1.0")
-        a_manifest_path = os.path.join(a_path, ".click", "info", "a.manifest")
-        with mkfile(a_manifest_path) as manifest:
-            json.dump({"hooks": {"a-app": {}}}, manifest)
-        b_path = os.path.join(self.temp_dir, "b", "1.0")
-        b_manifest_path = os.path.join(b_path, ".click", "info", "b.manifest")
-        with mkfile(b_manifest_path) as manifest:
-            json.dump({"hooks": {"b-app": {}}}, manifest)
-        c_path = os.path.join(self.temp_dir, "c", "1.0")
-        c_manifest_path = os.path.join(c_path, ".click", "info", "c.manifest")
-        with mkfile(c_manifest_path) as manifest:
-            json.dump({"hooks": {"c-app": {}}}, manifest)
-        a_user_path = os.path.join(
-            self.temp_dir, ".click", "users", "test-user", "a")
-        os.makedirs(os.path.dirname(a_user_path))
-        os.symlink(a_path, a_user_path)
-        b_gcinuse_path = os.path.join(
-            self.temp_dir, ".click", "users", "@gcinuse", "b")
-        os.makedirs(os.path.dirname(b_gcinuse_path))
-        os.symlink(b_path, b_gcinuse_path)
-        mock_call.return_value = 1
-        mock_find_on_path.return_value = True
-        self.db.gc(verbose=False)
-        self.assertTrue(os.path.exists(a_path))
-        self.assertFalse(os.path.exists(b_path))
-        self.assertTrue(os.path.exists(c_path))
+        ], self._installed_packages_tuplify(
+            self.db.get_packages(all_versions=True)))
+
+    def test_app_running(self):
+        with self.run_in_subprocess("g_spawn_sync") as (enter, preloads):
+            enter()
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 0})
+            self.assertTrue(self.db.app_running("foo", "bar", "1.0"))
+            self.assertEqual(
+                [[b"upstart-app-pid", b"foo_bar_1.0"]], self.spawn_calls)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 1 << 8})
+            self.assertFalse(self.db.app_running("foo", "bar", "1.0"))
+
+    def test_any_app_running(self):
+        with self.run_in_subprocess(
+                "click_find_on_path", "g_spawn_sync",
+                ) as (enter, preloads):
+            enter()
+            manifest_path = os.path.join(
+                self.temp_dir, "a", "1.0", ".click", "info", "a.manifest")
+            with mkfile(manifest_path) as manifest:
+                json.dump({"hooks": {"a-app": {}}}, manifest)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 0})
+            preloads["click_find_on_path"].return_value = False
+            self.assertFalse(self.db.any_app_running("a", "1.0"))
+            preloads["click_find_on_path"].return_value = True
+            self.assertTrue(self.db.any_app_running("a", "1.0"))
+            self.assertEqual(
+                [[b"upstart-app-pid", b"a_a-app_1.0"]], self.spawn_calls)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 1 << 8})
+            self.assertFalse(self.db.any_app_running("a", "1.0"))
+
+    def test_maybe_remove_registered(self):
+        with self.run_in_subprocess(
+                "click_find_on_path", "g_spawn_sync",
+                ) as (enter, preloads):
+            enter()
+            version_path = os.path.join(self.temp_dir, "a", "1.0")
+            manifest_path = os.path.join(
+                version_path, ".click", "info", "a.manifest")
+            with mkfile(manifest_path) as manifest:
+                json.dump({"hooks": {"a-app": {}}}, manifest)
+            user_path = os.path.join(
+                self.temp_dir, ".click", "users", "test-user", "a")
+            os.makedirs(os.path.dirname(user_path))
+            os.symlink(version_path, user_path)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 0})
+            preloads["click_find_on_path"].return_value = True
+            self.db.maybe_remove("a", "1.0")
+            self.assertTrue(os.path.exists(version_path))
+            self.assertTrue(os.path.exists(user_path))
+
+    def test_maybe_remove_running(self):
+        with self.run_in_subprocess(
+                "click_find_on_path", "g_spawn_sync",
+                ) as (enter, preloads):
+            enter()
+            version_path = os.path.join(self.temp_dir, "a", "1.0")
+            manifest_path = os.path.join(
+                version_path, ".click", "info", "a.manifest")
+            with mkfile(manifest_path) as manifest:
+                json.dump({"hooks": {"a-app": {}}}, manifest)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 0})
+            preloads["click_find_on_path"].return_value = True
+            self.db.maybe_remove("a", "1.0")
+            gcinuse_path = os.path.join(
+                self.temp_dir, ".click", "users", "@gcinuse", "a")
+            self.assertTrue(os.path.islink(gcinuse_path))
+            self.assertEqual(version_path, os.readlink(gcinuse_path))
+            self.assertTrue(os.path.exists(version_path))
+            self.db.maybe_remove("a", "1.0")
+            self.assertTrue(os.path.islink(gcinuse_path))
+            self.assertEqual(version_path, os.readlink(gcinuse_path))
+            self.assertTrue(os.path.exists(version_path))
+
+    def test_maybe_remove_not_running(self):
+        with self.run_in_subprocess(
+                "click_find_on_path", "g_spawn_sync",
+                ) as (enter, preloads):
+            enter()
+            os.environ["TEST_QUIET"] = "1"
+            version_path = os.path.join(self.temp_dir, "a", "1.0")
+            manifest_path = os.path.join(
+                version_path, ".click", "info", "a.manifest")
+            with mkfile(manifest_path) as manifest:
+                json.dump({"hooks": {"a-app": {}}}, manifest)
+            current_path = os.path.join(self.temp_dir, "a", "current")
+            os.symlink("1.0", current_path)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 1 << 8})
+            preloads["click_find_on_path"].return_value = True
+            self.db.maybe_remove("a", "1.0")
+            gcinuse_path = os.path.join(
+                self.temp_dir, ".click", "users", "@gcinuse", "a")
+            self.assertFalse(os.path.islink(gcinuse_path))
+            self.assertFalse(os.path.exists(os.path.join(self.temp_dir, "a")))
+
+    def test_gc(self):
+        with self.run_in_subprocess(
+                "click_find_on_path", "g_spawn_sync",
+                ) as (enter, preloads):
+            enter()
+            os.environ["TEST_QUIET"] = "1"
+            a_path = os.path.join(self.temp_dir, "a", "1.0")
+            a_manifest_path = os.path.join(
+                a_path, ".click", "info", "a.manifest")
+            with mkfile(a_manifest_path) as manifest:
+                json.dump({"hooks": {"a-app": {}}}, manifest)
+            b_path = os.path.join(self.temp_dir, "b", "1.0")
+            b_manifest_path = os.path.join(
+                b_path, ".click", "info", "b.manifest")
+            with mkfile(b_manifest_path) as manifest:
+                json.dump({"hooks": {"b-app": {}}}, manifest)
+            c_path = os.path.join(self.temp_dir, "c", "1.0")
+            c_manifest_path = os.path.join(
+                c_path, ".click", "info", "c.manifest")
+            with mkfile(c_manifest_path) as manifest:
+                json.dump({"hooks": {"c-app": {}}}, manifest)
+            a_user_path = os.path.join(
+                self.temp_dir, ".click", "users", "test-user", "a")
+            os.makedirs(os.path.dirname(a_user_path))
+            os.symlink(a_path, a_user_path)
+            b_gcinuse_path = os.path.join(
+                self.temp_dir, ".click", "users", "@gcinuse", "b")
+            os.makedirs(os.path.dirname(b_gcinuse_path))
+            os.symlink(b_path, b_gcinuse_path)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"upstart-app-pid": 1 << 8})
+            preloads["click_find_on_path"].return_value = True
+            self.db.gc()
+            self.assertTrue(os.path.exists(a_path))
+            self.assertFalse(os.path.exists(b_path))
+            self.assertTrue(os.path.exists(c_path))
 
     def _make_ownership_test(self):
         path = os.path.join(self.temp_dir, "a", "1.0")
@@ -215,60 +242,80 @@
         os.symlink(path, user_path)
         touch(os.path.join(self.temp_dir, ".click", "log"))
 
-    def test_clickpkg_paths(self):
-        self._make_ownership_test()
-        self.assertCountEqual([
-            self.temp_dir,
-            os.path.join(self.temp_dir, ".click"),
-            os.path.join(self.temp_dir, ".click", "log"),
-            os.path.join(self.temp_dir, ".click", "users"),
-            os.path.join(self.temp_dir, "a"),
-            os.path.join(self.temp_dir, "a", "1.0"),
-            os.path.join(self.temp_dir, "a", "1.0", ".click"),
-            os.path.join(self.temp_dir, "a", "1.0", ".click", "info"),
-            os.path.join(
-                self.temp_dir, "a", "1.0", ".click", "info", "a.manifest"),
-            os.path.join(self.temp_dir, "a", "current"),
-        ], list(self.db._clickpkg_paths()))
-
-    @mock.patch("pwd.getpwnam")
-    @mock.patch("os.chown")
-    def test_ensure_ownership_quick_if_correct(self, mock_chown,
-                                               mock_getpwnam):
-        mock_getpwnam.return_value = MockPasswd(pw_uid=1, pw_gid=1)
-        self._make_ownership_test()
-        with mock.patch("os.stat") as mock_stat:
-            mock_stat.side_effect = (
-                lambda path, *args, **kwargs: MockStatResult(
-                    path, st_uid=1, st_gid=1))
-            self.db.ensure_ownership()
-        self.assertFalse(mock_chown.called)
-
-    @mock.patch("pwd.getpwnam")
-    @mock.patch("os.chown")
-    def test_ensure_ownership(self, mock_chown, mock_getpwnam):
-        mock_getpwnam.return_value = MockPasswd(pw_uid=1, pw_gid=1)
-        self._make_ownership_test()
-        with mock.patch("os.stat") as mock_stat:
-            mock_stat.side_effect = (
-                lambda path, *args, **kwargs: MockStatResult(
-                    path, st_uid=2, st_gid=2))
-            self.db.ensure_ownership()
-        self.assertCountEqual([
-            self.temp_dir,
-            os.path.join(self.temp_dir, ".click"),
-            os.path.join(self.temp_dir, ".click", "log"),
-            os.path.join(self.temp_dir, ".click", "users"),
-            os.path.join(self.temp_dir, "a"),
-            os.path.join(self.temp_dir, "a", "1.0"),
-            os.path.join(self.temp_dir, "a", "1.0", ".click"),
-            os.path.join(self.temp_dir, "a", "1.0", ".click", "info"),
-            os.path.join(
-                self.temp_dir, "a", "1.0", ".click", "info", "a.manifest"),
-            os.path.join(self.temp_dir, "a", "current"),
-        ], [args[0][0] for args in mock_chown.call_args_list])
-        self.assertCountEqual(
-            [(1, 1)], set(args[0][1:] for args in mock_chown.call_args_list))
+    def _set_stat_side_effect(self, preloads, side_effect, limit):
+        limit = limit.encode()
+        preloads["__xstat"].side_effect = (
+            lambda ver, path, buf: side_effect(
+                "__xstat", limit, ver, path, buf))
+        preloads["__xstat64"].side_effect = (
+            lambda ver, path, buf: side_effect(
+                "__xstat64", limit, ver, path, buf))
+
+    def test_ensure_ownership_quick_if_correct(self):
+        def stat_side_effect(name, limit, ver, path, buf):
+            st = self.convert_stat_pointer(name, buf)
+            if path == limit:
+                st.st_uid = 1
+                st.st_gid = 1
+                return 0
+            else:
+                self.delegate_to_original(name)
+                return -1
+
+        with self.run_in_subprocess(
+                "chown", "getpwnam", "__xstat", "__xstat64",
+                ) as (enter, preloads):
+            enter()
+            preloads["getpwnam"].side_effect = (
+                lambda name: self.make_pointer(Passwd(pw_uid=1, pw_gid=1)))
+            self._set_stat_side_effect(
+                preloads, stat_side_effect, self.db.props.root)
+
+            self._make_ownership_test()
+            self.db.ensure_ownership()
+            self.assertFalse(preloads["chown"].called)
+
+    def test_ensure_ownership(self):
+        def stat_side_effect(name, limit, ver, path, buf):
+            st = self.convert_stat_pointer(name, buf)
+            if path == limit:
+                st.st_uid = 2
+                st.st_gid = 2
+                return 0
+            else:
+                self.delegate_to_original(name)
+                return -1
+
+        with self.run_in_subprocess(
+                "chown", "getpwnam", "__xstat", "__xstat64",
+                ) as (enter, preloads):
+            enter()
+            preloads["getpwnam"].side_effect = (
+                lambda name: self.make_pointer(Passwd(pw_uid=1, pw_gid=1)))
+            self._set_stat_side_effect(
+                preloads, stat_side_effect, self.db.props.root)
+
+            self._make_ownership_test()
+            self.db.ensure_ownership()
+            expected_paths = [
+                self.temp_dir,
+                os.path.join(self.temp_dir, ".click"),
+                os.path.join(self.temp_dir, ".click", "log"),
+                os.path.join(self.temp_dir, ".click", "users"),
+                os.path.join(self.temp_dir, "a"),
+                os.path.join(self.temp_dir, "a", "1.0"),
+                os.path.join(self.temp_dir, "a", "1.0", ".click"),
+                os.path.join(self.temp_dir, "a", "1.0", ".click", "info"),
+                os.path.join(
+                    self.temp_dir, "a", "1.0", ".click", "info", "a.manifest"),
+                os.path.join(self.temp_dir, "a", "current"),
+                ]
+            self.assertCountEqual(
+                [path.encode() for path in expected_paths],
+                [args[0][0] for args in preloads["chown"].call_args_list])
+            self.assertCountEqual(
+                [(1, 1)],
+                set(args[0][1:] for args in preloads["chown"].call_args_list))
 
 
 class TestClickDB(TestCase):
@@ -276,6 +323,11 @@
         super(TestClickDB, self).setUp()
         self.use_temp_dir()
 
+    def _installed_packages_tuplify(self, ip):
+        return [
+            (p.props.package, p.props.version, p.props.path, p.props.writeable)
+            for p in ip]
+
     def test_read_configuration(self):
         with open(os.path.join(self.temp_dir, "a.conf"), "w") as a:
             print("[Click Database]", file=a)
@@ -283,23 +335,27 @@
         with open(os.path.join(self.temp_dir, "b.conf"), "w") as b:
             print("[Click Database]", file=b)
             print("root = /b", file=b)
-        db = ClickDB(extra_root="/c", override_db_dir=self.temp_dir)
-        self.assertEqual(3, len(db))
-        self.assertEqual(["/a", "/b", "/c"], [d.root for d in db])
+        db = Click.DB()
+        db.read(db_dir=self.temp_dir)
+        db.add("/c")
+        self.assertEqual(3, db.props.size)
+        self.assertEqual(
+            ["/a", "/b", "/c"],
+            [db.get(i).props.root for i in range(db.props.size)])
 
-    def test_no_use_system(self):
+    def test_no_read(self):
         with open(os.path.join(self.temp_dir, "a.conf"), "w") as a:
             print("[Click Database]", file=a)
             print("root = /a", file=a)
-        db = ClickDB(use_system=False, override_db_dir=self.temp_dir)
-        self.assertEqual(0, len(db))
+        db = Click.DB()
+        self.assertEqual(0, db.props.size)
 
     def test_add(self):
-        db = ClickDB(use_system=False)
-        self.assertEqual(0, len(db))
+        db = Click.DB()
+        self.assertEqual(0, db.props.size)
         db.add("/new/root")
-        self.assertEqual(1, len(db))
-        self.assertEqual(["/new/root"], [d.root for d in db])
+        self.assertEqual(1, db.props.size)
+        self.assertEqual("/new/root", db.get(0).props.root)
 
     def test_overlay(self):
         with open(os.path.join(self.temp_dir, "00_custom.conf"), "w") as f:
@@ -308,8 +364,9 @@
         with open(os.path.join(self.temp_dir, "99_default.conf"), "w") as f:
             print("[Click Database]", file=f)
             print("root = /opt/click.ubuntu.com", file=f)
-        db = ClickDB(override_db_dir=self.temp_dir)
-        self.assertEqual("/opt/click.ubuntu.com", db.overlay)
+        db = Click.DB()
+        db.read(db_dir=self.temp_dir)
+        self.assertEqual("/opt/click.ubuntu.com", db.props.overlay)
 
     def test_path(self):
         with open(os.path.join(self.temp_dir, "a.conf"), "w") as a:
@@ -318,21 +375,24 @@
         with open(os.path.join(self.temp_dir, "b.conf"), "w") as b:
             print("[Click Database]", file=b)
             print("root = %s" % os.path.join(self.temp_dir, "b"), file=b)
-        db = ClickDB(override_db_dir=self.temp_dir)
-        self.assertRaises(KeyError, db.path, "pkg", "1.0")
+        db = Click.DB()
+        db.read(db_dir=self.temp_dir)
+        self.assertRaisesDatabaseError(
+            Click.DatabaseError.DOES_NOT_EXIST, db.get_path, "pkg", "1.0")
         os.makedirs(os.path.join(self.temp_dir, "a", "pkg", "1.0"))
         self.assertEqual(
             os.path.join(self.temp_dir, "a", "pkg", "1.0"),
-            db.path("pkg", "1.0"))
-        self.assertRaises(KeyError, db.path, "pkg", "1.1")
+            db.get_path("pkg", "1.0"))
+        self.assertRaisesDatabaseError(
+            Click.DatabaseError.DOES_NOT_EXIST, db.get_path, "pkg", "1.1")
         os.makedirs(os.path.join(self.temp_dir, "b", "pkg", "1.0"))
         self.assertEqual(
             os.path.join(self.temp_dir, "b", "pkg", "1.0"),
-            db.path("pkg", "1.0"))
+            db.get_path("pkg", "1.0"))
         os.makedirs(os.path.join(self.temp_dir, "b", "pkg", "1.1"))
         self.assertEqual(
             os.path.join(self.temp_dir, "b", "pkg", "1.1"),
-            db.path("pkg", "1.1"))
+            db.get_path("pkg", "1.1"))
 
     def test_packages_current(self):
         with open(os.path.join(self.temp_dir, "a.conf"), "w") as a:
@@ -341,8 +401,9 @@
         with open(os.path.join(self.temp_dir, "b.conf"), "w") as b:
             print("[Click Database]", file=b)
             print("root = %s" % os.path.join(self.temp_dir, "b"), file=b)
-        db = ClickDB(override_db_dir=self.temp_dir)
-        self.assertEqual([], list(db.packages()))
+        db = Click.DB()
+        db.read(db_dir=self.temp_dir)
+        self.assertEqual([], list(db.get_packages(all_versions=False)))
         os.makedirs(os.path.join(self.temp_dir, "a", "pkg1", "1.0"))
         os.symlink("1.0", os.path.join(self.temp_dir, "a", "pkg1", "current"))
         os.makedirs(os.path.join(self.temp_dir, "b", "pkg1", "1.1"))
@@ -354,7 +415,8 @@
         self.assertEqual([
             ("pkg1", "1.1", pkg1_current, True),
             ("pkg2", "0.1", pkg2_current, True),
-        ], list(db.packages()))
+        ], self._installed_packages_tuplify(
+            db.get_packages(all_versions=False)))
 
     def test_packages_all(self):
         with open(os.path.join(self.temp_dir, "a.conf"), "w") as a:
@@ -363,8 +425,9 @@
         with open(os.path.join(self.temp_dir, "b.conf"), "w") as b:
             print("[Click Database]", file=b)
             print("root = %s" % os.path.join(self.temp_dir, "b"), file=b)
-        db = ClickDB(override_db_dir=self.temp_dir)
-        self.assertEqual([], list(db.packages()))
+        db = Click.DB()
+        db.read(db_dir=self.temp_dir)
+        self.assertEqual([], list(db.get_packages(all_versions=False)))
         os.makedirs(os.path.join(self.temp_dir, "a", "pkg1", "1.0"))
         os.symlink("1.0", os.path.join(self.temp_dir, "a", "pkg1", "current"))
         os.makedirs(os.path.join(self.temp_dir, "b", "pkg1", "1.1"))
@@ -378,4 +441,5 @@
              True),
             ("pkg1", "1.0", os.path.join(self.temp_dir, "a", "pkg1", "1.0"),
              False),
-        ], list(db.packages(all_versions=True)))
+        ], self._installed_packages_tuplify(
+            db.get_packages(all_versions=True)))
 
=== modified file 'click/tests/test_hooks.py'
--- click/tests/test_hooks.py	2014-02-19 15:31:55 +0000
+++ click/tests/test_hooks.py	2014-03-06 07:04:44 +0000
@@ -27,824 +27,957 @@
     ]
 
 
-import contextlib
+from functools import partial
+from itertools import takewhile
 import json
 import os
 from textwrap import dedent
 
-from click import hooks
-from click.database import ClickDB
-from click.hooks import (
-    ClickHook,
-    ClickPatternFormatter,
-    package_install_hooks,
-    package_remove_hooks,
-    )
-from click.user import ClickUser
-from click.tests.helpers import TestCase, mkfile, mkfile_utf8, mock
-
-
[e-mail]
-def temp_hooks_dir(new_dir):
-    old_dir = hooks.hooks_dir
-    try:
-        hooks.hooks_dir = new_dir
-        yield
-    finally:
-        hooks.hooks_dir = old_dir
+from gi.repository import Click, GLib
+
+from click.tests.gimock_types import Passwd
+from click.tests.helpers import TestCase, mkfile, mkfile_utf8
 
 
 class TestClickPatternFormatter(TestCase):
-    def setUp(self):
-        super(TestClickPatternFormatter, self).setUp()
-        self.formatter = ClickPatternFormatter()
+    def _make_variant(self, **kwargs):
+        # pygobject's Variant creator can't handle maybe types, so we have
+        # to do this by hand.
+        builder = GLib.VariantBuilder.new(GLib.VariantType.new("a{sms}"))
+        for key, value in kwargs.items():
+            entry = GLib.VariantBuilder.new(GLib.VariantType.new("{sms}"))
+            entry.add_value(GLib.Variant.new_string(key))
+            entry.add_value(GLib.Variant.new_maybe(
+                GLib.VariantType.new("s"),
+                None if value is None else GLib.Variant.new_string(value)))
+            builder.add_value(entry.end())
+        return builder.end()
 
     def test_expands_provided_keys(self):
         self.assertEqual(
-            "foo.bar", self.formatter.format("foo.${key}", key="bar"))
+            "foo.bar",
+            Click.pattern_format("foo.${key}", self._make_variant(key="bar")))
         self.assertEqual(
             "foo.barbaz",
-            self.formatter.format(
-                "foo.${key1}${key2}", key1="bar", key2="baz"))
+            Click.pattern_format(
+                "foo.${key1}${key2}",
+                self._make_variant(key1="bar", key2="baz")))
 
     def test_expands_missing_keys_to_empty_string(self):
-        self.assertEqual("xy", self.formatter.format("x${key}y"))
+        self.assertEqual(
+            "xy", Click.pattern_format("x${key}y", self._make_variant()))
 
     def test_preserves_unmatched_dollar(self):
-        self.assertEqual("$", self.formatter.format("$"))
-        self.assertEqual("$ {foo}", self.formatter.format("$ {foo}"))
-        self.assertEqual("x${y", self.formatter.format("${key}${y", key="x"))
+        self.assertEqual("$", Click.pattern_format("$", self._make_variant()))
+        self.assertEqual(
+            "$ {foo}", Click.pattern_format("$ {foo}", self._make_variant()))
+        self.assertEqual(
+            "x${y",
+            Click.pattern_format("${key}${y", self._make_variant(key="x")))
 
     def test_double_dollar(self):
-        self.assertEqual("$", self.formatter.format("$$"))
-        self.assertEqual("${foo}", self.formatter.format("$${foo}"))
-        self.assertEqual("x$y", self.formatter.format("x$$${key}", key="y"))
+        self.assertEqual("$", Click.pattern_format("$$", self._make_variant()))
+        self.assertEqual(
+            "${foo}", Click.pattern_format("$${foo}", self._make_variant()))
+        self.assertEqual(
+            "x$y",
+            Click.pattern_format("x$$${key}", self._make_variant(key="y")))
 
     def test_possible_expansion(self):
         self.assertEqual(
             {"id": "abc"},
-            self.formatter.possible_expansion(
-                "x_abc_1", "x_${id}_${num}", num="1"))
+            Click.pattern_possible_expansion(
+                "x_abc_1", "x_${id}_${num}",
+                self._make_variant(num="1")).unpack())
         self.assertIsNone(
-            self.formatter.possible_expansion(
-                "x_abc_1", "x_${id}_${num}", num="2"))
+            Click.pattern_possible_expansion(
+                "x_abc_1", "x_${id}_${num}", self._make_variant(num="2")))
 
 
 class TestClickHookBase(TestCase):
     def setUp(self):
         super(TestClickHookBase, self).setUp()
         self.use_temp_dir()
-        self.db = ClickDB(self.temp_dir)
+        self.db = Click.DB()
+        self.db.add(self.temp_dir)
+        self.spawn_calls = []
+
+    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))
+
+    def g_spawn_sync_side_effect(self, status_map, working_directory, argv,
+                                 envp, flags, child_setup, user_data,
+                                 standard_output, standard_error, exit_status,
+                                 error):
+        self.spawn_calls.append(list(takewhile(lambda x: x is not None, argv)))
+        if argv[0] in status_map:
+            exit_status[0] = status_map[argv[0]]
+        else:
+            self.delegate_to_original("g_spawn_sync")
+        return 0
 
 
 class TestClickHookSystemLevel(TestClickHookBase):
     def test_open(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print(dedent("""\
-                Pattern: /usr/share/test/${id}.test
-                # Comment
-                Exec: test-update
-                User: root
-                """), file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertCountEqual(["Pattern", "Exec", "User"], hook.keys())
-        self.assertEqual("/usr/share/test/${id}.test", hook["pattern"])
-        self.assertEqual("test-update", hook["exec"])
-        self.assertFalse(hook.user_level)
+        with self.run_in_subprocess(
+                "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("""\
+                    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())
+            self.assertEqual(
+                "/usr/share/test/${id}.test", hook.get_field("pattern"))
+            self.assertEqual("test-update", hook.get_field("exec"))
+            self.assertFalse(hook.props.is_user_level)
 
     def test_hook_name_absent(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: /usr/share/test/${id}.test", file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual("test", hook.hook_name)
+        with self.run_in_subprocess(
+                "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)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual("test", hook.get_hook_name())
 
     def test_hook_name_present(self):
-        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)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual("other", hook.hook_name)
+        with self.run_in_subprocess(
+                "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)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual("other", hook.get_hook_name())
 
     def test_invalid_app_id(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print(dedent("""\
-                Pattern: /usr/share/test/${id}.test
-                # Comment
-                Exec: test-update
-                User: root
-                """), file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertRaises(
-            ValueError, hook.app_id, "package", "0.1", "app_name")
-        self.assertRaises(
-            ValueError, hook.app_id, "package", "0.1", "app/name")
+        with self.run_in_subprocess(
+                "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("""\
+                    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,
+                "package", "0.1", "app_name")
+            self.assertRaisesHooksError(
+                Click.HooksError.BAD_APP_NAME, hook.get_app_id,
+                "package", "0.1", "app/name")
 
     def test_short_id_invalid(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: /usr/share/test/${short-id}.test", file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        # It would perhaps be better if unrecognised $-expansions raised
-        # KeyError, but they don't right now.
-        self.assertEqual(
-            "/usr/share/test/.test",
-            hook.pattern("package", "0.1", "app-name"))
+        with self.run_in_subprocess(
+                "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)
+            hook = Click.Hook.open(self.db, "test")
+            # It would perhaps be better if unrecognised $-expansions raised
+            # KeyError, but they don't right now.
+            self.assertEqual(
+                "/usr/share/test/.test",
+                hook.get_pattern("package", "0.1", "app-name"))
 
     def test_short_id_valid_with_single_version(self):
-        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)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual(
-            "/usr/share/test/package_app-name.test",
-            hook.pattern("package", "0.1", "app-name"))
-
-    @mock.patch("subprocess.check_call")
-    def test_run_commands(self, mock_check_call):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Exec: test-update", file=f)
-            print("User: root", file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual("root", hook._run_commands_user(user=None))
-        hook._run_commands(user=None)
-        mock_check_call.assert_called_once_with(
-            "test-update", preexec_fn=mock.ANY, shell=True)
-
-    def test_previous_entries(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-        link_one = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        link_two = os.path.join(
-            self.temp_dir, "org.example.package_test-app_2.0.test")
-        os.symlink("dummy", link_one)
-        os.symlink("dummy", link_two)
-        os.symlink("dummy", os.path.join(self.temp_dir, "malformed"))
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertCountEqual([
-            (link_one, "org.example.package", "1.0", "test-app"),
-            (link_two, "org.example.package", "2.0", "test-app"),
-        ], list(hook._previous_entries()))
+        with self.run_in_subprocess(
+                "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)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual(
+                "/usr/share/test/package_app-name.test",
+                hook.get_pattern("package", "0.1", "app-name"))
+
+    def test_run_commands(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "g_spawn_sync") as (enter, preloads):
+            enter()
+            self._setup_hooks_dir(preloads)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"/bin/sh": 0})
+            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
+                print("Exec: test-update", file=f)
+                print("User: root", file=f)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual(
+                "root", hook.get_run_commands_user(user_name=None))
+            hook.run_commands(user_name=None)
+            self.assertEqual(
+                [[b"/bin/sh", b"-c", b"test-update"]], self.spawn_calls)
 
     def test_install_package(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-        os.makedirs(os.path.join(self.temp_dir, "org.example.package", "1.0"))
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package(
-            "org.example.package", "1.0", "test-app", "foo/bar")
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        target_path = os.path.join(
-            self.temp_dir, "org.example.package", "1.0", "foo", "bar")
-        self.assertTrue(os.path.islink(symlink_path))
-        self.assertEqual(target_path, os.readlink(symlink_path))
+        with self.run_in_subprocess(
+                "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)
+            os.makedirs(
+                os.path.join(self.temp_dir, "org.example.package", "1.0"))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo/bar")
+            symlink_path = os.path.join(
+                self.temp_dir, "org.example.package_test-app_1.0.test")
+            target_path = os.path.join(
+                self.temp_dir, "org.example.package", "1.0", "foo", "bar")
+            self.assertTrue(os.path.islink(symlink_path))
+            self.assertEqual(target_path, os.readlink(symlink_path))
 
     def test_install_package_trailing_slash(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: %s/${id}/" % self.temp_dir, file=f)
-        os.makedirs(os.path.join(self.temp_dir, "org.example.package", "1.0"))
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package("org.example.package", "1.0", "test-app", "foo")
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0")
-        target_path = os.path.join(
-            self.temp_dir, "org.example.package", "1.0", "foo")
-        self.assertTrue(os.path.islink(symlink_path))
-        self.assertEqual(target_path, os.readlink(symlink_path))
+        with self.run_in_subprocess(
+                "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)
+            os.makedirs(
+                os.path.join(self.temp_dir, "org.example.package", "1.0"))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo")
+            symlink_path = os.path.join(
+                self.temp_dir, "org.example.package_test-app_1.0")
+            target_path = os.path.join(
+                self.temp_dir, "org.example.package", "1.0", "foo")
+            self.assertTrue(os.path.islink(symlink_path))
+            self.assertEqual(target_path, os.readlink(symlink_path))
 
     def test_upgrade(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        os.symlink("old-target", symlink_path)
-        os.makedirs(os.path.join(self.temp_dir, "org.example.package", "1.0"))
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package(
-            "org.example.package", "1.0", "test-app", "foo/bar")
-        target_path = os.path.join(
-            self.temp_dir, "org.example.package", "1.0", "foo", "bar")
-        self.assertTrue(os.path.islink(symlink_path))
-        self.assertEqual(target_path, os.readlink(symlink_path))
+        with self.run_in_subprocess(
+                "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)
+            symlink_path = os.path.join(
+                self.temp_dir, "org.example.package_test-app_1.0.test")
+            os.symlink("old-target", symlink_path)
+            os.makedirs(
+                os.path.join(self.temp_dir, "org.example.package", "1.0"))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo/bar")
+            target_path = os.path.join(
+                self.temp_dir, "org.example.package", "1.0", "foo", "bar")
+            self.assertTrue(os.path.islink(symlink_path))
+            self.assertEqual(target_path, os.readlink(symlink_path))
 
     def test_remove_package(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("Pattern: %s/${id}.test" % self.temp_dir, file=f)
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        os.symlink("old-target", symlink_path)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        hook.remove_package("org.example.package", "1.0", "test-app")
-        self.assertFalse(os.path.exists(symlink_path))
+        with self.run_in_subprocess(
+                "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)
+            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")
+            self.assertFalse(os.path.exists(symlink_path))
 
     def test_install(self):
-        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({
-                "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({
-                "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"))
-        with temp_hooks_dir(os.path.join(self.temp_dir, "hooks")):
-            hook = ClickHook.open(self.db, "new")
-        hook.install()
-        path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.new")
-        self.assertTrue(os.path.lexists(path_1))
-        self.assertEqual(
-            os.path.join(self.temp_dir, "test-1", "1.0", "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, "test-2", "2.0", "target-2"),
-            os.readlink(path_2))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            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({
+                    "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({
+                    "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()
+            path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.new")
+            self.assertTrue(os.path.lexists(path_1))
+            self.assertEqual(
+                os.path.join(self.temp_dir, "test-1", "1.0", "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, "test-2", "2.0", "target-2"),
+                os.readlink(path_2))
 
     def test_remove(self):
-        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"))
-        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"))
-        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"), path_2)
-        with temp_hooks_dir(os.path.join(self.temp_dir, "hooks")):
-            hook = ClickHook.open(self.db, "old")
-        hook.remove()
-        self.assertFalse(os.path.exists(path_1))
-        self.assertFalse(os.path.exists(path_2))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            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"))
+            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"))
+            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"),
+                path_2)
+            hook = Click.Hook.open(self.db, "old")
+            hook.remove()
+            self.assertFalse(os.path.exists(path_1))
+            self.assertFalse(os.path.exists(path_2))
 
     def test_sync(self):
-        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.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"))
-        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"), 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, "test-3", "1.0", "target-3"), path_3)
-        with temp_hooks_dir(os.path.join(self.temp_dir, "hooks")):
-            hook = ClickHook.open(self.db, "test")
-        hook.sync()
-        self.assertTrue(os.path.lexists(path_1))
-        self.assertEqual(
-            os.path.join(self.temp_dir, "test-1", "1.0", "target-1"),
-            os.readlink(path_1))
-        self.assertTrue(os.path.lexists(path_2))
-        self.assertEqual(
-            os.path.join(self.temp_dir, "test-2", "1.1", "target-2"),
-            os.readlink(path_2))
-        self.assertFalse(os.path.lexists(path_3))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            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.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"))
+            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"),
+                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, "test-3", "1.0", "target-3"),
+                path_3)
+            hook = Click.Hook.open(self.db, "test")
+            hook.sync()
+            self.assertTrue(os.path.lexists(path_1))
+            self.assertEqual(
+                os.path.join(self.temp_dir, "test-1", "1.0", "target-1"),
+                os.readlink(path_1))
+            self.assertTrue(os.path.lexists(path_2))
+            self.assertEqual(
+                os.path.join(self.temp_dir, "test-2", "1.1", "target-2"),
+                os.readlink(path_2))
+            self.assertFalse(os.path.lexists(path_3))
 
 
 class TestClickHookUserLevel(TestClickHookBase):
     def test_open(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print(dedent("""\
-                User-Level: yes
-                Pattern: ${home}/.local/share/test/${id}.test
-                # Comment
-                Exec: test-update
-                """), file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertCountEqual(["User-Level", "Pattern", "Exec"], hook.keys())
-        self.assertEqual(
-            "${home}/.local/share/test/${id}.test", hook["pattern"])
-        self.assertEqual("test-update", hook["exec"])
-        self.assertTrue(hook.user_level)
+        with self.run_in_subprocess(
+                "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("""\
+                    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())
+            self.assertEqual(
+                "${home}/.local/share/test/${id}.test",
+                hook.get_field("pattern"))
+            self.assertEqual("test-update", hook.get_field("exec"))
+            self.assertTrue(hook.props.is_user_level)
 
     def test_hook_name_absent(self):
-        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)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual("test", hook.hook_name)
+        with self.run_in_subprocess(
+                "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)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual("test", hook.get_hook_name())
 
     def test_hook_name_present(self):
-        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)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual("other", hook.hook_name)
+        with self.run_in_subprocess(
+                "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)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual("other", hook.get_hook_name())
 
     def test_invalid_app_id(self):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print(dedent("""\
-                User-Level: yes
-                Pattern: ${home}/.local/share/test/${id}.test
-                # Comment
-                Exec: test-update
-                """), file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertRaises(
-            ValueError, hook.app_id, "package", "0.1", "app_name")
-        self.assertRaises(
-            ValueError, hook.app_id, "package", "0.1", "app/name")
-
-    @mock.patch("pwd.getpwnam")
-    def test_short_id_valid(self, mock_getpwnam):
-        class MockPasswd:
-            def __init__(self, pw_dir):
-                self.pw_dir = pw_dir
-
-        mock_getpwnam.return_value = MockPasswd(pw_dir="/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)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual(
-            "/mock/.local/share/test/package_app-name.test",
-            hook.pattern("package", "0.1", "app-name", user="mock"))
-
-    @mock.patch("subprocess.check_call")
-    def test_run_commands(self, mock_check_call):
-        with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
-            print("User-Level: yes", file=f)
-            print("Exec: test-update", file=f)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertEqual(
-            "test-user", hook._run_commands_user(user="test-user"))
-        hook._run_commands(user="test-user")
-        mock_check_call.assert_called_once_with(
-            "test-update", preexec_fn=mock.ANY, shell=True)
-
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_previous_entries(self, mock_user_home):
-        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)
-        link_one = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        link_two = os.path.join(
-            self.temp_dir, "org.example.package_test-app_2.0.test")
-        os.symlink("dummy", link_one)
-        os.symlink("dummy", link_two)
-        os.symlink("dummy", os.path.join(self.temp_dir, "malformed"))
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        self.assertCountEqual([
-            (link_one, "org.example.package", "1.0", "test-app"),
-            (link_two, "org.example.package", "2.0", "test-app"),
-        ], list(hook._previous_entries(user="test-user")))
-
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_install_package(self, mock_user_home):
-        mock_user_home.return_value = "/home/test-user"
-        with temp_hooks_dir(self.temp_dir):
+        with self.run_in_subprocess(
+                "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("""\
+                    User-Level: yes
+                    Pattern: ${home}/.local/share/test/${id}.test
+                    # Comment
+                    Exec: test-update
+                    """), file=f)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertRaisesHooksError(
+                Click.HooksError.BAD_APP_NAME, hook.get_app_id,
+                "package", "0.1", "app_name")
+            self.assertRaisesHooksError(
+                Click.HooksError.BAD_APP_NAME, hook.get_app_id,
+                "package", "0.1", "app/name")
+
+    def test_short_id_valid(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "getpwnam") as (enter, preloads):
+            enter()
+            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)
+            hook = Click.Hook.open(self.db, "test")
+            self.assertEqual(
+                "/mock/.local/share/test/package_app-name.test",
+                hook.get_pattern(
+                    "package", "0.1", "app-name", user_name="mock"))
+
+    def test_run_commands(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "g_spawn_sync") as (enter, preloads):
+            enter()
+            self._setup_hooks_dir(preloads)
+            preloads["g_spawn_sync"].side_effect = partial(
+                self.g_spawn_sync_side_effect, {b"/bin/sh": 0})
+            with mkfile(os.path.join(self.temp_dir, "test.hook")) as f:
+                print("User-Level: yes", file=f)
+                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.assertEqual(
+                [[b"/bin/sh", b"-c", b"test-update"]], self.spawn_calls)
+
+    def test_install_package(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            self._setup_hooks_dir(preloads)
+            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 = ClickUser(self.db, user="test-user")
+            user_db = Click.User.for_user(self.db, "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)
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package(
-            "org.example.package", "1.0", "test-app", "foo/bar",
-            user="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",
-            "org.example.package", "foo", "bar")
-        self.assertTrue(os.path.islink(symlink_path))
-        self.assertEqual(target_path, os.readlink(symlink_path))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo/bar",
+                user_name="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",
+                "org.example.package", "foo", "bar")
+            self.assertTrue(os.path.islink(symlink_path))
+            self.assertEqual(target_path, os.readlink(symlink_path))
 
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_install_package_trailing_slash(self, mock_user_home):
-        mock_user_home.return_value = "/home/test-user"
-        with temp_hooks_dir(self.temp_dir):
+    def test_install_package_trailing_slash(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            self._setup_hooks_dir(preloads)
+            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 = ClickUser(self.db, user="test-user")
+            user_db = Click.User.for_user(self.db, "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)
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package(
-            "org.example.package", "1.0", "test-app", "foo", user="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",
-            "org.example.package", "foo")
-        self.assertTrue(os.path.islink(symlink_path))
-        self.assertEqual(target_path, os.readlink(symlink_path))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo",
+                user_name="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",
+                "org.example.package", "foo")
+            self.assertTrue(os.path.islink(symlink_path))
+            self.assertEqual(target_path, os.readlink(symlink_path))
 
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_install_package_removes_previous(self, mock_user_home):
-        mock_user_home.return_value = "/home/test-user"
-        with temp_hooks_dir(self.temp_dir):
+    def test_install_package_removes_previous(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            self._setup_hooks_dir(preloads)
+            preloads["click_get_user_home"].return_value = "/home/test-user"
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.0"))
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.1"))
-            user_db = ClickUser(self.db, user="test-user")
+            user_db = Click.User.for_user(self.db, "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)
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package(
-            "org.example.package", "1.0", "test-app", "foo/bar",
-            user="test-user")
-        hook.install_package(
-            "org.example.package", "1.1", "test-app", "foo/bar",
-            user="test-user")
-        old_symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.1.test")
-        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",
-            "org.example.package", "foo", "bar")
-        self.assertEqual(target_path, os.readlink(symlink_path))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo/bar",
+                user_name="test-user")
+            hook.install_package(
+                "org.example.package", "1.1", "test-app", "foo/bar",
+                user_name="test-user")
+            old_symlink_path = os.path.join(
+                self.temp_dir, "org.example.package_test-app_1.0.test")
+            symlink_path = os.path.join(
+                self.temp_dir, "org.example.package_test-app_1.1.test")
+            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",
+                "org.example.package", "foo", "bar")
+            self.assertEqual(target_path, os.readlink(symlink_path))
 
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_upgrade(self, mock_user_home):
-        mock_user_home.return_value = "/home/test-user"
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        os.symlink("old-target", symlink_path)
-        with temp_hooks_dir(self.temp_dir):
+    def test_upgrade(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            self._setup_hooks_dir(preloads)
+            preloads["click_get_user_home"].return_value = "/home/test-user"
+            symlink_path = os.path.join(
+                self.temp_dir, "org.example.package_test-app_1.0.test")
+            os.symlink("old-target", symlink_path)
             os.makedirs(os.path.join(
                 self.temp_dir, "org.example.package", "1.0"))
-            user_db = ClickUser(self.db, user="test-user")
+            user_db = Click.User.for_user(self.db, "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)
-            hook = ClickHook.open(self.db, "test")
-        hook.install_package(
-            "org.example.package", "1.0", "test-app", "foo/bar",
-            user="test-user")
-        target_path = os.path.join(
-            self.temp_dir, ".click", "users", "test-user",
-            "org.example.package", "foo", "bar")
-        self.assertTrue(os.path.islink(symlink_path))
-        self.assertEqual(target_path, os.readlink(symlink_path))
-
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_remove_package(self, mock_user_home):
-        mock_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)
-        symlink_path = os.path.join(
-            self.temp_dir, "org.example.package_test-app_1.0.test")
-        os.symlink("old-target", symlink_path)
-        with temp_hooks_dir(self.temp_dir):
-            hook = ClickHook.open(self.db, "test")
-        hook.remove_package(
-            "org.example.package", "1.0", "test-app", user="test-user")
-        self.assertFalse(os.path.exists(symlink_path))
-
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_install(self, mock_user_home):
-        mock_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 = ClickUser(self.db, user="test-user")
-        with mkfile_utf8(os.path.join(
-                self.temp_dir, "test-1", "1.0", ".click", "info",
-                "test-1.manifest")) as f:
-            json.dump({
-                "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({
-                "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")
-        with temp_hooks_dir(os.path.join(self.temp_dir, "hooks")):
-            hook = ClickHook.open(self.db, "new")
-        hook.install()
-        path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.new")
-        self.assertTrue(os.path.lexists(path_1))
-        self.assertEqual(
-            os.path.join(
-                self.temp_dir, ".click", "users", "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",
-                "target-2"),
-            os.readlink(path_2))
-
-        os.unlink(path_1)
-        os.unlink(path_2)
-        hook.install(user="another-user")
-        self.assertFalse(os.path.lexists(path_1))
-        self.assertFalse(os.path.lexists(path_2))
-
-        hook.install(user="test-user")
-        self.assertTrue(os.path.lexists(path_1))
-        self.assertEqual(
-            os.path.join(
-                self.temp_dir, ".click", "users", "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",
-                "target-2"),
-            os.readlink(path_2))
-
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_remove(self, mock_user_home):
-        mock_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 = ClickUser(self.db, user="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"))
-        path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.old")
-        os.symlink(os.path.join(user_db.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")
-        path_2 = os.path.join(self.temp_dir, "test-2_test2-app_2.0.old")
-        os.symlink(os.path.join(user_db.path("test-2"), "target-2"), path_2)
-        with temp_hooks_dir(os.path.join(self.temp_dir, "hooks")):
-            hook = ClickHook.open(self.db, "old")
-        hook.remove()
-        self.assertFalse(os.path.exists(path_1))
-        self.assertFalse(os.path.exists(path_2))
-
-    @mock.patch("click.hooks.ClickHook._user_home")
-    def test_sync(self, mock_user_home):
-        mock_user_home.return_value = "/home/test-user"
-        with mkfile(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 = ClickUser(self.db, user="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")
-        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",
-                "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",
-                "target-3"),
-            path_3)
-        with temp_hooks_dir(os.path.join(self.temp_dir, "hooks")):
-            hook = ClickHook.open(self.db, "test")
-        hook.sync(user="test-user")
-        self.assertTrue(os.path.lexists(path_1))
-        self.assertEqual(
-            os.path.join(
-                self.temp_dir, ".click", "users", "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",
-                "target-2"),
-            os.readlink(path_2))
-        self.assertFalse(os.path.lexists(path_3))
+            hook = Click.Hook.open(self.db, "test")
+            hook.install_package(
+                "org.example.package", "1.0", "test-app", "foo/bar",
+                user_name="test-user")
+            target_path = os.path.join(
+                self.temp_dir, ".click", "users", "test-user",
+                "org.example.package", "foo", "bar")
+            self.assertTrue(os.path.islink(symlink_path))
+            self.assertEqual(target_path, os.readlink(symlink_path))
+
+    def test_remove_package(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            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)
+            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")
+            self.assertFalse(os.path.exists(symlink_path))
+
+    def test_install(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            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({
+                    "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({
+                    "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")
+            self._setup_hooks_dir(
+                preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
+            hook = Click.Hook.open(self.db, "new")
+            hook.install()
+            path_1 = os.path.join(self.temp_dir, "test-1_test1-app_1.0.new")
+            self.assertTrue(os.path.lexists(path_1))
+            self.assertEqual(
+                os.path.join(
+                    self.temp_dir, ".click", "users", "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",
+                    "target-2"),
+                os.readlink(path_2))
+
+            os.unlink(path_1)
+            os.unlink(path_2)
+            hook.install(user_name="another-user")
+            self.assertFalse(os.path.lexists(path_1))
+            self.assertFalse(os.path.lexists(path_2))
+
+            hook.install(user_name="test-user")
+            self.assertTrue(os.path.lexists(path_1))
+            self.assertEqual(
+                os.path.join(
+                    self.temp_dir, ".click", "users", "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",
+                    "target-2"),
+                os.readlink(path_2))
+
+    def test_remove(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            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"))
+            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")
+            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)
+            self._setup_hooks_dir(
+                preloads, hooks_dir=os.path.join(self.temp_dir, "hooks"))
+            hook = Click.Hook.open(self.db, "old")
+            hook.remove()
+            self.assertFalse(os.path.exists(path_1))
+            self.assertFalse(os.path.exists(path_2))
+
+    def test_sync(self):
+        with self.run_in_subprocess(
+                "click_get_hooks_dir", "click_get_user_home",
+                ) as (enter, preloads):
+            enter()
+            preloads["click_get_user_home"].return_value = "/home/test-user"
+            self._setup_hooks_dir(preloads)
+            with mkfile(
+                    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")
+            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",
+                    "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",
+                    "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")
+            self.assertTrue(os.path.lexists(path_1))
+            self.assertEqual(
+                os.path.join(
+                    self.temp_dir, ".click", "users", "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",
+                    "target-2"),
+                os.readlink(path_2))
+            self.assertFalse(os.path.lexists(path_3))
 
 
 class TestPackageInstallHooks(TestClickHookBase):
     def test_removes_old_hooks(self):
-        hooks_dir = os.path.join(self.temp_dir, "hooks")
-        with mkfile(os.path.join(hooks_dir, "unity.hook")) as f:
-            print("Pattern: %s/unity/${id}.scope" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-        with mkfile(os.path.join(hooks_dir, "yelp-docs.hook")) as f:
-            print("Pattern: %s/yelp/docs-${id}.txt" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-            print("Hook-Name: yelp", file=f)
-        with mkfile(os.path.join(hooks_dir, "yelp-other.hook")) as f:
-            print("Pattern: %s/yelp/other-${id}.txt" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-            print("Hook-Name: yelp", file=f)
-        os.mkdir(os.path.join(self.temp_dir, "unity"))
-        unity_path = os.path.join(self.temp_dir, "unity", "test_app_1.0.scope")
-        os.symlink("dummy", unity_path)
-        os.mkdir(os.path.join(self.temp_dir, "yelp"))
-        yelp_docs_path = os.path.join(
-            self.temp_dir, "yelp", "docs-test_app_1.0.txt")
-        os.symlink("dummy", yelp_docs_path)
-        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)
-        with temp_hooks_dir(hooks_dir):
-            package_install_hooks(self.db, "test", "1.0", "1.1")
-        self.assertFalse(os.path.lexists(unity_path))
-        self.assertFalse(os.path.lexists(yelp_docs_path))
-        self.assertFalse(os.path.lexists(yelp_other_path))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            enter()
+            hooks_dir = os.path.join(self.temp_dir, "hooks")
+            self._setup_hooks_dir(preloads, hooks_dir=hooks_dir)
+            with mkfile(os.path.join(hooks_dir, "unity.hook")) as f:
+                print("Pattern: %s/unity/${id}.scope" % self.temp_dir, file=f)
+                print("Single-Version: yes", file=f)
+            with mkfile(os.path.join(hooks_dir, "yelp-docs.hook")) as f:
+                print("Pattern: %s/yelp/docs-${id}.txt" % self.temp_dir,
+                      file=f)
+                print("Single-Version: yes", file=f)
+                print("Hook-Name: yelp", file=f)
+            with mkfile(os.path.join(hooks_dir, "yelp-other.hook")) as f:
+                print("Pattern: %s/yelp/other-${id}.txt" % self.temp_dir,
+                      file=f)
+                print("Single-Version: yes", file=f)
+                print("Hook-Name: yelp", file=f)
+            os.mkdir(os.path.join(self.temp_dir, "unity"))
+            unity_path = os.path.join(
+                self.temp_dir, "unity", "test_app_1.0.scope")
+            os.symlink("dummy", unity_path)
+            os.mkdir(os.path.join(self.temp_dir, "yelp"))
+            yelp_docs_path = os.path.join(
+                self.temp_dir, "yelp", "docs-test_app_1.0.txt")
+            os.symlink("dummy", yelp_docs_path)
+            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)
+            Click.package_install_hooks(self.db, "test", "1.0", "1.1")
+            self.assertFalse(os.path.lexists(unity_path))
+            self.assertFalse(os.path.lexists(yelp_docs_path))
+            self.assertFalse(os.path.lexists(yelp_other_path))
 
     def test_installs_new_hooks(self):
-        hooks_dir = os.path.join(self.temp_dir, "hooks")
-        with mkfile(os.path.join(hooks_dir, "a.hook")) as f:
-            print("Pattern: %s/a/${id}.a" % self.temp_dir, file=f)
-        with mkfile(os.path.join(hooks_dir, "b-1.hook")) as f:
-            print("Pattern: %s/b/1-${id}.b" % self.temp_dir, file=f)
-            print("Hook-Name: b", file=f)
-        with mkfile(os.path.join(hooks_dir, "b-2.hook")) as f:
-            print("Pattern: %s/b/2-${id}.b" % self.temp_dir, file=f)
-            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)
-        with temp_hooks_dir(hooks_dir):
-            package_install_hooks(self.db, "test", "1.0", "1.1")
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "a", "test_app_1.1.a")))
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "b", "1-test_app_1.1.b")))
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "b", "2-test_app_1.1.b")))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            enter()
+            hooks_dir = os.path.join(self.temp_dir, "hooks")
+            self._setup_hooks_dir(preloads, hooks_dir=hooks_dir)
+            with mkfile(os.path.join(hooks_dir, "a.hook")) as f:
+                print("Pattern: %s/a/${id}.a" % self.temp_dir, file=f)
+            with mkfile(os.path.join(hooks_dir, "b-1.hook")) as f:
+                print("Pattern: %s/b/1-${id}.b" % self.temp_dir, file=f)
+                print("Hook-Name: b", file=f)
+            with mkfile(os.path.join(hooks_dir, "b-2.hook")) as f:
+                print("Pattern: %s/b/2-${id}.b" % self.temp_dir, file=f)
+                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)
+            Click.package_install_hooks(self.db, "test", "1.0", "1.1")
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "a", "test_app_1.1.a")))
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "b", "1-test_app_1.1.b")))
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "b", "2-test_app_1.1.b")))
 
     def test_upgrades_existing_hooks(self):
-        hooks_dir = os.path.join(self.temp_dir, "hooks")
-        with mkfile(os.path.join(hooks_dir, "a.hook")) as f:
-            print("Pattern: %s/a/${id}.a" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-        with mkfile(os.path.join(hooks_dir, "b-1.hook")) as f:
-            print("Pattern: %s/b/1-${id}.b" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-            print("Hook-Name: b", file=f)
-        with mkfile(os.path.join(hooks_dir, "b-2.hook")) as f:
-            print("Pattern: %s/b/2-${id}.b" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-            print("Hook-Name: b", file=f)
-        with mkfile(os.path.join(hooks_dir, "c.hook")) as f:
-            print("Pattern: %s/c/${id}.c" % self.temp_dir, file=f)
-            print("Single-Version: yes", file=f)
-        os.mkdir(os.path.join(self.temp_dir, "a"))
-        a_path = os.path.join(self.temp_dir, "a", "test_app_1.0.a")
-        os.symlink("dummy", a_path)
-        os.mkdir(os.path.join(self.temp_dir, "b"))
-        b_irrelevant_path = os.path.join(
-            self.temp_dir, "b", "1-test_other-app_1.0.b")
-        os.symlink("dummy", b_irrelevant_path)
-        b_1_path = os.path.join(self.temp_dir, "b", "1-test_app_1.0.b")
-        os.symlink("dummy", b_1_path)
-        b_2_path = os.path.join(self.temp_dir, "b", "2-test_app_1.0.b")
-        os.symlink("dummy", b_2_path)
-        os.mkdir(os.path.join(self.temp_dir, "c"))
-        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": {"a": "foo.a", "b": "foo.b"}}}, 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", "c": "foo.c"}}
-                }, f)
-        with temp_hooks_dir(hooks_dir):
-            package_install_hooks(self.db, "test", "1.0", "1.1")
-        self.assertFalse(os.path.lexists(a_path))
-        self.assertTrue(os.path.lexists(b_irrelevant_path))
-        self.assertFalse(os.path.lexists(b_1_path))
-        self.assertFalse(os.path.lexists(b_2_path))
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "a", "test_app_1.1.a")))
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "b", "1-test_app_1.1.b")))
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "b", "2-test_app_1.1.b")))
-        self.assertTrue(os.path.lexists(
-            os.path.join(self.temp_dir, "c", "test_app_1.1.c")))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            enter()
+            hooks_dir = os.path.join(self.temp_dir, "hooks")
+            self._setup_hooks_dir(preloads, hooks_dir=hooks_dir)
+            with mkfile(os.path.join(hooks_dir, "a.hook")) as f:
+                print("Pattern: %s/a/${id}.a" % self.temp_dir, file=f)
+                print("Single-Version: yes", file=f)
+            with mkfile(os.path.join(hooks_dir, "b-1.hook")) as f:
+                print("Pattern: %s/b/1-${id}.b" % self.temp_dir, file=f)
+                print("Single-Version: yes", file=f)
+                print("Hook-Name: b", file=f)
+            with mkfile(os.path.join(hooks_dir, "b-2.hook")) as f:
+                print("Pattern: %s/b/2-${id}.b" % self.temp_dir, file=f)
+                print("Single-Version: yes", file=f)
+                print("Hook-Name: b", file=f)
+            with mkfile(os.path.join(hooks_dir, "c.hook")) as f:
+                print("Pattern: %s/c/${id}.c" % self.temp_dir, file=f)
+                print("Single-Version: yes", file=f)
+            os.mkdir(os.path.join(self.temp_dir, "a"))
+            a_path = os.path.join(self.temp_dir, "a", "test_app_1.0.a")
+            os.symlink("dummy", a_path)
+            os.mkdir(os.path.join(self.temp_dir, "b"))
+            b_irrelevant_path = os.path.join(
+                self.temp_dir, "b", "1-test_other-app_1.0.b")
+            os.symlink("dummy", b_irrelevant_path)
+            b_1_path = os.path.join(self.temp_dir, "b", "1-test_app_1.0.b")
+            os.symlink("dummy", b_1_path)
+            b_2_path = os.path.join(self.temp_dir, "b", "2-test_app_1.0.b")
+            os.symlink("dummy", b_2_path)
+            os.mkdir(os.path.join(self.temp_dir, "c"))
+            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": {"a": "foo.a", "b": "foo.b"}}}, 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", "c": "foo.c"}}
+                    }, f)
+            Click.package_install_hooks(self.db, "test", "1.0", "1.1")
+            self.assertFalse(os.path.lexists(a_path))
+            self.assertTrue(os.path.lexists(b_irrelevant_path))
+            self.assertFalse(os.path.lexists(b_1_path))
+            self.assertFalse(os.path.lexists(b_2_path))
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "a", "test_app_1.1.a")))
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "b", "1-test_app_1.1.b")))
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "b", "2-test_app_1.1.b")))
+            self.assertTrue(os.path.lexists(
+                os.path.join(self.temp_dir, "c", "test_app_1.1.c")))
 
 
 class TestPackageRemoveHooks(TestClickHookBase):
     def test_removes_hooks(self):
-        hooks_dir = os.path.join(self.temp_dir, "hooks")
-        with mkfile(os.path.join(hooks_dir, "unity.hook")) as f:
-            print("Pattern: %s/unity/${id}.scope" % self.temp_dir, file=f)
-        with mkfile(os.path.join(hooks_dir, "yelp-docs.hook")) as f:
-            print("Pattern: %s/yelp/docs-${id}.txt" % self.temp_dir, file=f)
-            print("Hook-Name: yelp", file=f)
-        with mkfile(os.path.join(hooks_dir, "yelp-other.hook")) as f:
-            print("Pattern: %s/yelp/other-${id}.txt" % self.temp_dir, file=f)
-            print("Hook-Name: yelp", file=f)
-        os.mkdir(os.path.join(self.temp_dir, "unity"))
-        unity_path = os.path.join(self.temp_dir, "unity", "test_app_1.0.scope")
-        os.symlink("dummy", unity_path)
-        os.mkdir(os.path.join(self.temp_dir, "yelp"))
-        yelp_docs_path = os.path.join(
-            self.temp_dir, "yelp", "docs-test_app_1.0.txt")
-        os.symlink("dummy", yelp_docs_path)
-        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 temp_hooks_dir(hooks_dir):
-            package_remove_hooks(self.db, "test", "1.0")
-        self.assertFalse(os.path.lexists(unity_path))
-        self.assertFalse(os.path.lexists(yelp_docs_path))
-        self.assertFalse(os.path.lexists(yelp_other_path))
+        with self.run_in_subprocess(
+                "click_get_hooks_dir") as (enter, preloads):
+            enter()
+            hooks_dir = os.path.join(self.temp_dir, "hooks")
+            self._setup_hooks_dir(preloads, hooks_dir=hooks_dir)
+            with mkfile(os.path.join(hooks_dir, "unity.hook")) as f:
+                print("Pattern: %s/unity/${id}.scope" % self.temp_dir, file=f)
+            with mkfile(os.path.join(hooks_dir, "yelp-docs.hook")) as f:
+                print("Pattern: %s/yelp/docs-${id}.txt" % self.temp_dir,
+                      file=f)
+                print("Hook-Name: yelp", file=f)
+            with mkfile(os.path.join(hooks_dir, "yelp-other.hook")) as f:
+                print("Pattern: %s/yelp/other-${id}.txt" % self.temp_dir,
+                      file=f)
+                print("Hook-Name: yelp", file=f)
+            os.mkdir(os.path.join(self.temp_dir, "unity"))
+            unity_path = os.path.join(
+                self.temp_dir, "unity", "test_app_1.0.scope")
+            os.symlink("dummy", unity_path)
+            os.mkdir(os.path.join(self.temp_dir, "yelp"))
+            yelp_docs_path = os.path.join(
+                self.temp_dir, "yelp", "docs-test_app_1.0.txt")
+            os.symlink("dummy", yelp_docs_path)
+            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)
+            Click.package_remove_hooks(self.db, "test", "1.0")
+            self.assertFalse(os.path.lexists(unity_path))
+            self.assertFalse(os.path.lexists(yelp_docs_path))
+            self.assertFalse(os.path.lexists(yelp_other_path))
 
=== modified file 'click/tests/test_install.py'
--- click/tests/test_install.py	2014-01-22 14:02:33 +0000
+++ click/tests/test_install.py	2014-03-06 07:04:44 +0000
@@ -34,10 +34,10 @@
 from unittest import skipUnless
 
 from debian.deb822 import Deb822
+from gi.repository import Click
 
-from click import install, osextras
+from click import install
 from click.build import ClickBuilder
-from click.database import ClickDB
 from click.install import (
     ClickInstaller,
     ClickInstallerAuditError,
@@ -68,7 +68,8 @@
     def setUp(self):
         super(TestClickInstaller, self).setUp()
         self.use_temp_dir()
-        self.db = ClickDB(self.temp_dir)
+        self.db = Click.DB()
+        self.db.add(self.temp_dir)
 
     def make_fake_package(self, control_fields=None, manifest=None,
                           control_scripts=None, data_files=None):
@@ -90,7 +91,7 @@
         for name, contents in control_scripts.items():
             with mkfile(os.path.join(control_dir, name)) as script:
                 script.write(contents)
-        osextras.ensuredir(data_dir)
+        Click.ensuredir(data_dir)
         for name, path in data_files.items():
             if path is None:
                 touch(os.path.join(data_dir, name))
@@ -108,11 +109,11 @@
         old_dir = install.frameworks_dir
         try:
             install.frameworks_dir = os.path.join(self.temp_dir, "frameworks")
-            osextras.ensuredir(install.frameworks_dir)
+            Click.ensuredir(install.frameworks_dir)
             touch(os.path.join(install.frameworks_dir, "%s.framework" % name))
             yield
         finally:
-            osextras.unlink_force(
+            Click.unlink_force(
                 os.path.join(install.frameworks_dir, "%s.framework" % name))
             install.frameworks_dir = old_dir
 
@@ -342,7 +343,7 @@
     @skipUnless(
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
-    @mock.patch("click.install.package_install_hooks")
+    @mock.patch("gi.repository.Click.package_install_hooks")
     def test_install(self, mock_package_install_hooks):
         path = self.make_fake_package(
             control_fields={
@@ -361,7 +362,8 @@
             control_scripts={"preinst": static_preinst},
             data_files={"foo": None})
         root = os.path.join(self.temp_dir, "root")
-        db = ClickDB(root)
+        db = Click.DB()
+        db.add(root)
         installer = ClickInstaller(db)
         with self.make_framework("ubuntu-sdk-13.10"), \
              mock_quiet_subprocess_call():
@@ -425,7 +427,9 @@
             control_scripts={"preinst": static_preinst},
             data_files={"foo": None})
         root = os.path.join(self.temp_dir, "root")
-        installer = ClickInstaller(ClickDB(root))
+        db = Click.DB()
+        db.add(root)
+        installer = ClickInstaller(db)
         with self.make_framework("ubuntu-sdk-13.10"), \
              mock.patch("subprocess.call") as mock_call:
             mock_call.side_effect = call_side_effect
@@ -437,8 +441,9 @@
     @skipUnless(
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
-    @mock.patch("click.install.package_install_hooks")
+    @mock.patch("gi.repository.Click.package_install_hooks")
     def test_upgrade(self, mock_package_install_hooks):
+        os.environ["TEST_QUIET"] = "1"
         path = self.make_fake_package(
             control_fields={
                 "Package": "test-package",
@@ -460,7 +465,8 @@
         inst_dir = os.path.join(package_dir, "current")
         os.makedirs(os.path.join(package_dir, "1.0"))
         os.symlink("1.0", inst_dir)
-        db = ClickDB(root)
+        db = Click.DB()
+        db.add(root)
         installer = ClickInstaller(db)
         with self.make_framework("ubuntu-sdk-13.10"), \
              mock_quiet_subprocess_call():
@@ -494,7 +500,7 @@
     @skipUnless(
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
-    @mock.patch("click.install.package_install_hooks")
+    @mock.patch("gi.repository.Click.package_install_hooks")
     def test_world_readable(self, mock_package_install_hooks):
         owner_only_file = os.path.join(self.temp_dir, "owner-only-file")
         touch(owner_only_file)
@@ -521,7 +527,8 @@
                 "world-readable-dir": owner_only_dir,
             })
         root = os.path.join(self.temp_dir, "root")
-        db = ClickDB(root)
+        db = Click.DB()
+        db.add(root)
         installer = ClickInstaller(db)
         with self.make_framework("ubuntu-sdk-13.10"), \
              mock_quiet_subprocess_call():
@@ -538,7 +545,7 @@
     @skipUnless(
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
-    @mock.patch("click.install.package_install_hooks")
+    @mock.patch("gi.repository.Click.package_install_hooks")
     @mock.patch("click.install.ClickInstaller._dpkg_architecture")
     def test_single_architecture(self, mock_dpkg_architecture,
                                  mock_package_install_hooks):
@@ -560,7 +567,8 @@
             },
             control_scripts={"preinst": static_preinst})
         root = os.path.join(self.temp_dir, "root")
-        db = ClickDB(root)
+        db = Click.DB()
+        db.add(root)
         installer = ClickInstaller(db)
         with self.make_framework("ubuntu-sdk-13.10"), \
              mock_quiet_subprocess_call():
@@ -571,7 +579,7 @@
     @skipUnless(
         os.path.exists(ClickInstaller(None)._preload_path()),
         "preload bits not built; installing packages will fail")
-    @mock.patch("click.install.package_install_hooks")
+    @mock.patch("gi.repository.Click.package_install_hooks")
     @mock.patch("click.install.ClickInstaller._dpkg_architecture")
     def test_multiple_architectures(self, mock_dpkg_architecture,
                                     mock_package_install_hooks):
@@ -593,7 +601,8 @@
             },
             control_scripts={"preinst": static_preinst})
         root = os.path.join(self.temp_dir, "root")
-        db = ClickDB(root)
+        db = Click.DB()
+        db.add(root)
         installer = ClickInstaller(db)
         with self.make_framework("ubuntu-sdk-13.10"), \
              mock_quiet_subprocess_call():
 
=== modified file 'click/tests/test_osextras.py'
--- click/tests/test_osextras.py	2013-09-04 15:59:18 +0000
+++ click/tests/test_osextras.py	2014-03-06 07:04:44 +0000
@@ -17,35 +17,34 @@
 
 from __future__ import print_function
 __all__ = [
-    'TestOSExtras',
+    'TestOSExtrasNative',
+    'TestOSExtrasPython',
     ]
 
 
 import os
 
+from gi.repository import Click, GLib
+
 from click import osextras
-from click.tests.helpers import TestCase, touch
-
-
-class TestOSExtras(TestCase):
-    def setUp(self):
-        super(TestOSExtras, self).setUp()
-        self.use_temp_dir()
-
+from click.tests.helpers import TestCase, mock, touch
+
+
+class TestOSExtrasBaseMixin:
     def test_ensuredir_previously_missing(self):
         new_dir = os.path.join(self.temp_dir, "dir")
-        osextras.ensuredir(new_dir)
+        self.mod.ensuredir(new_dir)
         self.assertTrue(os.path.isdir(new_dir))
 
     def test_ensuredir_previously_present(self):
         new_dir = os.path.join(self.temp_dir, "dir")
         os.mkdir(new_dir)
-        osextras.ensuredir(new_dir)
+        self.mod.ensuredir(new_dir)
         self.assertTrue(os.path.isdir(new_dir))
 
     def test_find_on_path_missing_environment(self):
         os.environ.pop("PATH", None)
-        self.assertFalse(osextras.find_on_path("ls"))
+        self.assertFalse(self.mod.find_on_path("ls"))
 
     def test_find_on_path_present_executable(self):
         bin_dir = os.path.join(self.temp_dir, "bin")
@@ -53,69 +52,112 @@
         touch(program)
         os.chmod(program, 0o755)
         os.environ["PATH"] = bin_dir
-        self.assertTrue(osextras.find_on_path("program"))
+        self.assertTrue(self.mod.find_on_path("program"))
 
     def test_find_on_path_present_not_executable(self):
         bin_dir = os.path.join(self.temp_dir, "bin")
         touch(os.path.join(bin_dir, "program"))
         os.environ["PATH"] = bin_dir
-        self.assertFalse(osextras.find_on_path("program"))
-
-    def test_listdir_directory_present(self):
-        new_dir = os.path.join(self.temp_dir, "dir")
-        touch(os.path.join(new_dir, "file"))
-        self.assertEqual(["file"], osextras.listdir_force(new_dir))
-
-    def test_listdir_directory_missing(self):
-        new_dir = os.path.join(self.temp_dir, "dir")
-        self.assertEqual([], osextras.listdir_force(new_dir))
-
-    def test_listdir_oserror(self):
-        not_dir = os.path.join(self.temp_dir, "file")
-        touch(not_dir)
-        self.assertRaises(OSError, osextras.listdir_force, not_dir)
+        self.assertFalse(self.mod.find_on_path("program"))
+
+    def test_find_on_path_requires_regular_file(self):
+        bin_dir = os.path.join(self.temp_dir, "bin")
+        self.mod.ensuredir(os.path.join(bin_dir, "subdir"))
+        os.environ["PATH"] = bin_dir
+        self.assertFalse(self.mod.find_on_path("subdir"))
 
     def test_unlink_file_present(self):
         path = os.path.join(self.temp_dir, "file")
         touch(path)
-        osextras.unlink_force(path)
+        self.mod.unlink_force(path)
         self.assertFalse(os.path.exists(path))
 
     def test_unlink_file_missing(self):
         path = os.path.join(self.temp_dir, "file")
-        osextras.unlink_force(path)
+        self.mod.unlink_force(path)
         self.assertFalse(os.path.exists(path))
 
-    def test_unlink_oserror(self):
-        path = os.path.join(self.temp_dir, "dir")
-        os.mkdir(path)
-        self.assertRaises(OSError, osextras.unlink_force, path)
-
     def test_symlink_file_present(self):
         path = os.path.join(self.temp_dir, "link")
         touch(path)
-        osextras.symlink_force("source", path)
+        self.mod.symlink_force("source", path)
         self.assertTrue(os.path.islink(path))
         self.assertEqual("source", os.readlink(path))
 
     def test_symlink_link_present(self):
         path = os.path.join(self.temp_dir, "link")
         os.symlink("old", path)
-        osextras.symlink_force("source", path)
+        self.mod.symlink_force("source", path)
         self.assertTrue(os.path.islink(path))
         self.assertEqual("source", os.readlink(path))
 
     def test_symlink_missing(self):
         path = os.path.join(self.temp_dir, "link")
-        osextras.symlink_force("source", path)
+        self.mod.symlink_force("source", path)
         self.assertTrue(os.path.islink(path))
         self.assertEqual("source", os.readlink(path))
 
     def test_umask(self):
         old_mask = os.umask(0o040)
         try:
-            self.assertEqual(0o040, osextras.get_umask())
+            self.assertEqual(0o040, self.mod.get_umask())
             os.umask(0o002)
-            self.assertEqual(0o002, osextras.get_umask())
+            self.assertEqual(0o002, self.mod.get_umask())
         finally:
             os.umask(old_mask)
+
+
+class TestOSExtrasNative(TestCase, TestOSExtrasBaseMixin):
+    def setUp(self):
+        super(TestOSExtrasNative, self).setUp()
+        self.use_temp_dir()
+        self.mod = Click
+
+    def test_dir_read_name_directory_present(self):
+        new_dir = os.path.join(self.temp_dir, "dir")
+        touch(os.path.join(new_dir, "file"))
+        d = Click.Dir.open(new_dir, 0)
+        self.assertEqual("file", d.read_name())
+        self.assertIsNone(d.read_name())
+
+    def test_dir_read_name_directory_missing(self):
+        new_dir = os.path.join(self.temp_dir, "dir")
+        d = Click.Dir.open(new_dir, 0)
+        self.assertIsNone(d.read_name())
+
+    def test_dir_open_error(self):
+        not_dir = os.path.join(self.temp_dir, "file")
+        touch(not_dir)
+        self.assertRaisesFileError(
+            GLib.FileError.NOTDIR, Click.Dir.open, not_dir, 0)
+
+    def test_unlink_error(self):
+        path = os.path.join(self.temp_dir, "dir")
+        os.mkdir(path)
+        self.assertRaisesFileError(mock.ANY, self.mod.unlink_force, path)
+
+
+class TestOSExtrasPython(TestCase, TestOSExtrasBaseMixin):
+    def setUp(self):
+        super(TestOSExtrasPython, self).setUp()
+        self.use_temp_dir()
+        self.mod = osextras
+
+    def test_listdir_directory_present(self):
+        new_dir = os.path.join(self.temp_dir, "dir")
+        touch(os.path.join(new_dir, "file"))
+        self.assertEqual(["file"], osextras.listdir_force(new_dir))
+
+    def test_listdir_directory_missing(self):
+        new_dir = os.path.join(self.temp_dir, "dir")
+        self.assertEqual([], osextras.listdir_force(new_dir))
+
+    def test_listdir_oserror(self):
+        not_dir = os.path.join(self.temp_dir, "file")
+        touch(not_dir)
+        self.assertRaises(OSError, osextras.listdir_force, not_dir)
+
+    def test_unlink_oserror(self):
+        path = os.path.join(self.temp_dir, "dir")
+        os.mkdir(path)
+        self.assertRaises(OSError, self.mod.unlink_force, path)
 
=== added file 'click/tests/test_query.py'
--- click/tests/test_query.py	1970-01-01 00:00:00 +0000
+++ click/tests/test_query.py	2014-03-06 07:04:44 +0000
@@ -0,0 +1,52 @@
+# Copyright (C) 2014 Canonical Ltd.
+# Author: Colin Watson <[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/>.
+
+"""Unit tests for click.query."""
+
+from __future__ import print_function
+__all__ = [
+    'TestQuery',
+    ]
+
+
+import os
+
+from gi.repository import Click
+
+from click.tests.helpers import TestCase, touch
+
+
+class TestQuery(TestCase):
+    def setUp(self):
+        super(TestQuery, self).setUp()
+        self.use_temp_dir()
+
+    def test_find_package_directory_missing(self):
+        path = os.path.join(self.temp_dir, "nonexistent")
+        self.assertRaisesQueryError(
+            Click.QueryError.PATH, Click.find_package_directory, path)
+
+    def test_find_package_directory(self):
+        info = os.path.join(self.temp_dir, ".click", "info")
+        path = os.path.join(self.temp_dir, "file")
+        Click.ensuredir(info)
+        touch(path)
+        pkgdir = Click.find_package_directory(path)
+        self.assertEqual(self.temp_dir, pkgdir)
+
+    def test_find_package_directory_outside(self):
+        self.assertRaisesQueryError(
+            Click.QueryError.NO_PACKAGE_DIR, Click.find_package_directory,
+            "/bin")
 
=== modified file 'click/tests/test_user.py'
--- click/tests/test_user.py	2014-03-01 23:54:08 +0000
+++ click/tests/test_user.py	2014-03-06 07:04:44 +0000
@@ -25,24 +25,26 @@
 
 import os
 
-from click.database import ClickDB
+from gi.repository import Click
+
 from click.tests.helpers import TestCase
-from click.user import ClickUser
 
 
 class TestClickUser(TestCase):
     def setUp(self):
         super(TestClickUser, self).setUp()
         self.use_temp_dir()
-        self.db = ClickDB(self.temp_dir, use_system=False)
+        self.db = Click.DB()
+        self.db.add(self.temp_dir)
 
     def _setUpMultiDB(self):
-        self.multi_db = ClickDB(use_system=False)
+        self.multi_db = Click.DB()
         self.multi_db.add(os.path.join(self.temp_dir, "custom"))
         self.multi_db.add(os.path.join(self.temp_dir, "click"))
         user_dbs = [
-            os.path.join(d.root, ".click", "users", "user")
-            for d in self.multi_db
+            os.path.join(
+                self.multi_db.get(i).props.root, ".click", "users", "user")
+            for i in range(self.multi_db.props.size)
         ]
         a_1_0 = os.path.join(self.temp_dir, "custom", "a", "1.0")
         os.makedirs(a_1_0)
@@ -58,80 +60,90 @@
         os.makedirs(user_dbs[1])
         os.symlink(a_1_1, os.path.join(user_dbs[1], "a"))
         os.symlink(c_0_1, os.path.join(user_dbs[1], "c"))
-        return user_dbs, ClickUser(self.multi_db, "user")
-
-    def test_overlay_db(self):
+        return user_dbs, Click.User.for_user(self.multi_db, "user")
+
+    def test_new_no_db(self):
+        with self.run_in_subprocess(
+                "click_get_db_dir", "g_get_user_name") as (enter, preloads):
+            enter()
+            preloads["click_get_db_dir"].side_effect = (
+                lambda: self.make_string(self.temp_dir))
+            preloads["g_get_user_name"].side_effect = (
+                lambda: self.make_string("test-user"))
+            db_root = os.path.join(self.temp_dir, "db")
+            os.makedirs(db_root)
+            with open(os.path.join(self.temp_dir, "db.conf"), "w") as f:
+                print("[Click Database]", file=f)
+                print("root = %s" % db_root, file=f)
+            registry = Click.User.for_user()
+            self.assertEqual(
+                os.path.join(db_root, ".click", "users", "test-user"),
+                registry.get_overlay_db())
+
+    def test_get_overlay_db(self):
         self.assertEqual(
             os.path.join(self.temp_dir, ".click", "users", "user"),
-            ClickUser(self.db, "user").overlay_db)
-
-    def test_iter_missing(self):
-        db = ClickDB(
-            os.path.join(self.temp_dir, "nonexistent"), use_system=False)
-        registry = ClickUser(db)
-        self.assertEqual([], list(registry))
-
-    def test_iter(self):
-        registry = ClickUser(self.db, "user")
-        os.makedirs(registry.overlay_db)
-        os.symlink("/1.0", os.path.join(registry.overlay_db, "a"))
-        os.symlink("/1.1", os.path.join(registry.overlay_db, "b"))
-        self.assertCountEqual(["a", "b"], list(registry))
-
-    def test_iter_multiple_root(self):
-        _, registry = self._setUpMultiDB()
-        self.assertCountEqual(["a", "b", "c"], list(registry))
-
-    def test_len_missing(self):
-        db = ClickDB(
-            os.path.join(self.temp_dir, "nonexistent"), use_system=False)
-        registry = ClickUser(db)
-        self.assertEqual(0, len(registry))
-
-    def test_len(self):
-        registry = ClickUser(self.db, "user")
-        os.makedirs(registry.overlay_db)
-        os.symlink("/1.0", os.path.join(registry.overlay_db, "a"))
-        os.symlink("/1.1", os.path.join(registry.overlay_db, "b"))
-        self.assertEqual(2, len(registry))
-
-    def test_len_multiple_root(self):
-        _, registry = self._setUpMultiDB()
-        self.assertEqual(3, len(registry))
-
-    def test_getitem_missing(self):
-        registry = ClickUser(self.db, "user")
-        self.assertRaises(KeyError, registry.__getitem__, "a")
-
-    def test_getitem(self):
-        registry = ClickUser(self.db, "user")
-        os.makedirs(registry.overlay_db)
-        os.symlink("/1.0", os.path.join(registry.overlay_db, "a"))
-        self.assertEqual("1.0", registry["a"])
-
-    def test_getitem_multiple_root(self):
-        _, registry = self._setUpMultiDB()
-        self.assertEqual("1.1", registry["a"])
-        self.assertEqual("2.0", registry["b"])
-        self.assertEqual("0.1", registry["c"])
+            Click.User.for_user(self.db, "user").get_overlay_db())
+
+    def test_get_package_names_missing(self):
+        db = Click.DB()
+        db.add(os.path.join(self.temp_dir, "nonexistent"))
+        registry = Click.User.for_user(db)
+        self.assertEqual([], list(registry.get_package_names()))
+
+    def test_get_package_names(self):
+        registry = Click.User.for_user(self.db, "user")
+        os.makedirs(registry.get_overlay_db())
+        os.symlink("/1.0", os.path.join(registry.get_overlay_db(), "a"))
+        os.symlink("/1.1", os.path.join(registry.get_overlay_db(), "b"))
+        self.assertCountEqual(["a", "b"], list(registry.get_package_names()))
+
+    def test_get_package_names_multiple_root(self):
+        _, registry = self._setUpMultiDB()
+        self.assertCountEqual(
+            ["a", "b", "c"], list(registry.get_package_names()))
+
+    def test_get_version_missing(self):
+        registry = Click.User.for_user(self.db, "user")
+        self.assertRaisesUserError(
+            Click.UserError.NO_SUCH_PACKAGE, registry.get_version, "a")
+        self.assertFalse(registry.has_package_name("a"))
+
+    def test_get_version(self):
+        registry = Click.User.for_user(self.db, "user")
+        os.makedirs(registry.get_overlay_db())
+        os.symlink("/1.0", os.path.join(registry.get_overlay_db(), "a"))
+        self.assertEqual("1.0", registry.get_version("a"))
+        self.assertTrue(registry.has_package_name("a"))
+
+    def test_get_version_multiple_root(self):
+        _, registry = self._setUpMultiDB()
+        self.assertEqual("1.1", registry.get_version("a"))
+        self.assertEqual("2.0", registry.get_version("b"))
+        self.assertEqual("0.1", registry.get_version("c"))
+        self.assertTrue(registry.has_package_name("a"))
+        self.assertTrue(registry.has_package_name("b"))
+        self.assertTrue(registry.has_package_name("c"))
 
     def test_set_version_missing_target(self):
-        registry = ClickUser(self.db, "user")
-        self.assertRaises(KeyError, registry.set_version, "a", "1.0")
+        registry = Click.User.for_user(self.db, "user")
+        self.assertRaisesDatabaseError(