Merge lp:~nataliabidart/software-center/fix-977931 into lp:software-center/5.2

[Natalia Bidart]

- Unified package string parsing into a single method that will be used from either the command line arguments, or from the dbus method 'bringToFront'. This way, search will be consistent between all entry points.
- Also added proper test suites for the above.

[Michael Vogt (mvo)]

Thanks Natalia for this branch and sorry for my slow reply.

First let me say thanks for the work and the refactor and the excellent test, we shall use that
as a example.

This looks fine, there have been some changes in the 5.2 branch so I merged it and resolved
conflicts and tweaked it a bit more, please remerge lp:~mvo/software-center/fix-977931/ with this branch
and let me know what you think.

I was curious how to reproduce/understand the changes in appview.py, reviews.py that cause the model to
be "None". I revert that change but for me its not crashing so I wonder if that is still needed? Or is it
a random issue? Except for this (which I just would like to understand better how it happens) the branch
is +10 approve ;)

Additional thanks for unifying get_mock_options() and the with open() fix (and the cleanup) in test_database.py.

[Natalia Bidart (nataliabidart)]

Merged the branch suggested by mvo adding a minor tweaks about detetcting .deb files.

[lp:~nataliabidart/software-center/fix-977931]

2993. By Natalia Bidart on 2012-05-18

Merged 5.2 in.

2994. By Natalia Bidart on 2012-05-21

Merged 5.2 in.

[Michael Vogt (mvo)]

This looks great, I will merge it now into 5.2 (and it will be merged into trunk via 5.2 too).

review: Approve

=== modified file 'README'
--- README	2012-03-08 18:08:49 +0000
+++ README	2012-05-21 15:37:20 +0000
@@ -53,6 +53,7 @@
 SOFTWARE_CENTER_DISTRO_CODENAME - overwrite "lsb_release -c -s" output
 SOFTWARE_CENTER_ARCHITECTURE - overwrite the current architecture
 SOFTWARE_CENTER_NO_SC_AGENT - disable the software-center-agent
+SOFTWARE_CENTER_DISABLE_SPAWN_HELPER - disable everything that is run via the "SpawnHelper", i.e. recommender-agent, software-center-agent, reviews
 SOFTWARE_CENTER_DEBUG_TABS - show notebook tabs for debugging
 SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK - disables certificates checking in webkit views (for use in test environments)
 SOFTWARE_CENTER_FORCE_NON_SSL - disable SSL (for use in test environments)

=== modified file 'softwarecenter/backend/spawn_helper.py'
--- softwarecenter/backend/spawn_helper.py	2012-03-19 13:35:47 +0000
+++ softwarecenter/backend/spawn_helper.py	2012-05-21 15:37:20 +0000
@@ -86,6 +86,9 @@
         self.run(cmd)
 
     def run(self, cmd):
+        # only useful for debugging
+        if "SOFTWARE_CENTER_DISABLE_SPAWN_HELPER" in os.environ:
+            return
         self._cmd = cmd
         (pid, stdin, stdout, stderr) = GObject.spawn_async(
             cmd, flags=GObject.SPAWN_DO_NOT_REAP_CHILD,

=== modified file 'softwarecenter/db/__init__.py'
--- softwarecenter/db/__init__.py	2012-03-15 04:30:04 +0000
+++ softwarecenter/db/__init__.py	2012-05-21 15:37:20 +0000
@@ -1,9 +1,14 @@
 import logging
+
 try:
-    from debfile import DebFileApplication
+    from debfile import DebFileApplication, DebFileOpenError
     DebFileApplication  # pyflakes
+    DebFileOpenError  # pyflakes
 except:
     logging.exception("DebFileApplication import")
 
-    class DebFileApplication():
+    class DebFileApplication(object):
+        pass
+
+    class DebFileOpenError(Exception):
         pass

=== modified file 'softwarecenter/db/database.py'
--- softwarecenter/db/database.py	2012-04-12 10:15:36 +0000
+++ softwarecenter/db/database.py	2012-05-21 15:37:20 +0000
@@ -139,6 +139,10 @@
 
     def __init__(self, pathname=None, cache=None):
         GObject.GObject.__init__(self)
+        # initialize at creation time to avoid spurious AttributeError
+        self._use_agent = False
+        self._use_axi = False
+
         if pathname is None:
             pathname = softwarecenter.paths.XAPIAN_PATH
         self._db_pathname = pathname

=== modified file 'softwarecenter/db/debfile.py'
--- softwarecenter/db/debfile.py	2012-03-29 00:18:23 +0000
+++ softwarecenter/db/debfile.py	2012-05-21 15:37:20 +0000
@@ -27,12 +27,28 @@
 from softwarecenter.utils import ExecutionTime, utf8
 
 
+DEB_MIME_TYPE = 'application/x-debian-package'
+
+
+def is_deb_file(debfile):
+    mtype = guess_type(debfile)
+    return mtype is not None and DEB_MIME_TYPE in mtype
+
+
+class DebFileOpenError(Exception):
+    """ Raised if a DebFile fails to open """
+
+    def __init__(self, msg, path):
+        super(DebFileOpenError, self).__init__(msg)
+        self.path = path
+
+
 class DebFileApplication(Application):
 
     def __init__(self, debfile):
-        # sanity check
-        if not debfile.endswith(".deb"):
-            raise ValueError("Need a deb file, got '%s'" % debfile)
+        if not is_deb_file(debfile):
+            raise DebFileOpenError("Could not open %r." % debfile, debfile)
+
         # work out debname/appname
         debname = os.path.splitext(os.path.basename(debfile))[0]
         pkgname = debname.split('_')[0].lower()
@@ -50,7 +66,21 @@
     def __init__(self, db, doc=None, application=None):
         super(AppDetailsDebFile, self).__init__(db, doc, application)
         if doc:
-            raise ValueError("doc must be None for deb files")
+            raise DebFileOpenError("AppDetailsDebFile: doc must be None.")
+
+        self._error = None
+        # check errors before creating the DebPackage
+        if not os.path.exists(self._app.request):
+            self._error = _("Not found")
+            self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
+                "does not exist.")) % utf8(self._app.request)
+        elif not is_deb_file(self._app.request):
+            self._error = _("Not found")
+            self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
+                "is not a software package.")) % utf8(self._app.request)
+
+        if self._error is not None:
+            return
 
         try:
             with ExecutionTime("create DebPackage"):
@@ -59,23 +89,10 @@
                 self._deb = DebPackage(self._app.request, self._cache._cache)
         except:
             self._deb = None
-            self._pkg = None
-            if not os.path.exists(self._app.request):
-                self._error = _("Not found")
-                self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
-                    "does not exist.")) % utf8(self._app.request)
-            else:
-                mimetype = guess_type(self._app.request)
-                if mimetype[0] != "application/x-debian-package":
-                    self._error = _("Not found")
-                    self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
-                        "is not a software package.")) % utf8(
-                        self._app.request)
-                else:
-                    # deb files which are corrupt
-                    self._error = _("Internal Error")
-                    self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
-                        "could not be opened.")) % utf8(self._app.request)
+            # deb files which are corrupt
+            self._error = _("Internal Error")
+            self._error_not_found = utf8(_(u"The file \u201c%s\u201d "
+                "could not be opened.")) % utf8(self._app.request)
             return
 
         if self.pkgname and self.pkgname != self._app.pkgname:

=== modified file 'softwarecenter/enums.py'
--- softwarecenter/enums.py	2012-03-21 20:54:46 +0000
+++ softwarecenter/enums.py	2012-05-21 15:37:20 +0000
@@ -237,6 +237,12 @@
     REPAIR = "repair_dependencies"
 
 
+# Search separators
+class SearchSeparators:
+    REGULAR = " "
+    PACKAGE = ","
+
+
 # mouse event codes for back/forward buttons
 # TODO: consider whether we ought to get these values from gconf so that we
 #       can be sure to use the corresponding values used by Nautilus:

=== modified file 'softwarecenter/testutils.py'
--- softwarecenter/testutils.py	2012-03-19 14:23:52 +0000
+++ softwarecenter/testutils.py	2012-05-21 15:37:20 +0000
@@ -22,6 +22,7 @@
 import tempfile
 import time
 
+from mock import Mock
 
 m_dbus = m_polkit = m_aptd = None
 
@@ -145,7 +146,6 @@
     """ take a application and return a app where the details are a mock
         of the real details so they can easily be modified
     """
-    from mock import Mock
     import copy
     app = copy.copy(real_app)
     db = get_test_db()
@@ -160,6 +160,16 @@
     return app
 
 
+def get_mock_options():
+    """Return a mock suitable to act as SoftwareCenterAppGtk3's options."""
+    mock_options = Mock()
+    mock_options.display_navlog = False
+    mock_options.disable_apt_xapian_index = False
+    mock_options.disable_buy = False
+
+    return mock_options
+
+
 def setup_test_env():
     """ Setup environment suitable for running the test/* code in a checkout.
         This includes PYTHONPATH, sys.path and softwarecenter.paths.datadir.

=== modified file 'softwarecenter/ui/gtk3/SimpleGtkbuilderApp.py'
--- softwarecenter/ui/gtk3/SimpleGtkbuilderApp.py	2012-03-15 09:32:18 +0000
+++ softwarecenter/ui/gtk3/SimpleGtkbuilderApp.py	2012-05-21 15:37:20 +0000
@@ -23,9 +23,10 @@
 
 
 # based on SimpleGladeApp
-class SimpleGtkbuilderApp:
+class SimpleGtkbuilderApp(object):
 
     def __init__(self, path, domain):
+        super(SimpleGtkbuilderApp, self).__init__()
         self.builder = Gtk.Builder()
         self.builder.set_translation_domain(domain)
         self.builder.add_from_file(path)

=== modified file 'softwarecenter/ui/gtk3/app.py'
--- softwarecenter/ui/gtk3/app.py	2012-05-15 18:37:27 +0000
+++ softwarecenter/ui/gtk3/app.py	2012-05-21 15:37:20 +0000
@@ -31,6 +31,7 @@
 import gettext
 import logging
 import os
+import re
 import subprocess
 import sys
 import xapian
@@ -47,28 +48,35 @@
 
 # db imports
 from softwarecenter.db.application import Application
-from softwarecenter.db import DebFileApplication
+from softwarecenter.db import DebFileApplication, DebFileOpenError
 from softwarecenter.i18n import init_locale
 
 # misc imports
 from softwarecenter.plugin import PluginManager
 from softwarecenter.paths import SOFTWARE_CENTER_PLUGIN_DIRS
-from softwarecenter.enums import (Icons,
-                                  PkgStates,
-                                  ViewPages,
-                                  AppActions,
-                                  DB_SCHEMA_VERSION,
-                                  MOUSE_EVENT_FORWARD_BUTTON,
-                                  MOUSE_EVENT_BACK_BUTTON,
-                                  SOFTWARE_CENTER_TOS_LINK,
-                                  SOFTWARE_CENTER_NAME_KEYRING)
-from softwarecenter.utils import (clear_token_from_ubuntu_sso_sync,
-                                  get_http_proxy_string_from_gsettings,
-                                  wait_for_apt_cache_ready,
-                                  ExecutionTime,
-                                  is_unity_running)
-from softwarecenter.ui.gtk3.utils import (get_sc_icon_theme,
-                                          init_sc_css_provider)
+from softwarecenter.enums import (
+    AppActions,
+    DB_SCHEMA_VERSION,
+    Icons,
+    MOUSE_EVENT_FORWARD_BUTTON,
+    MOUSE_EVENT_BACK_BUTTON,
+    PkgStates,
+    SearchSeparators,
+    SOFTWARE_CENTER_TOS_LINK,
+    SOFTWARE_CENTER_NAME_KEYRING,
+    ViewPages,
+)
+from softwarecenter.utils import (
+    clear_token_from_ubuntu_sso_sync,
+    get_http_proxy_string_from_gsettings,
+    wait_for_apt_cache_ready,
+    ExecutionTime,
+    is_unity_running,
+)
+from softwarecenter.ui.gtk3.utils import (
+    get_sc_icon_theme,
+    init_sc_css_provider,
+)
 from softwarecenter.version import VERSION
 from softwarecenter.db.database import StoreDatabase
 try:
@@ -87,10 +95,14 @@
 from softwarecenter.ui.gtk3.panes.historypane import HistoryPane
 from softwarecenter.ui.gtk3.panes.globalpane import GlobalPane
 from softwarecenter.ui.gtk3.panes.pendingpane import PendingPane
-from softwarecenter.ui.gtk3.session.appmanager import (ApplicationManager,
-                                                       get_appmanager)
+from softwarecenter.ui.gtk3.session.appmanager import (
+    ApplicationManager,
+    get_appmanager,
+    )
 from softwarecenter.ui.gtk3.session.viewmanager import (
-    ViewManager, get_viewmanager)
+    ViewManager,
+    get_viewmanager,
+    )
 from softwarecenter.ui.gtk3.widgets.recommendations import (
     RecommendationsOptInDialog)
 
@@ -112,6 +124,10 @@
 from gi.repository import Gdk
 
 LOG = logging.getLogger(__name__)
+PACKAGE_PREFIX = 'apt:'
+# "apt:///" is a valid prefix for 'apt:pkgname' in alt+F2 in gnome
+PACKAGE_PREFIX_REGEX = re.compile('^%s(?:/{2,3})*' % PACKAGE_PREFIX)
+SEARCH_PREFIX = 'search:'
 
 
 # py3 compat
@@ -119,6 +135,64 @@
     return isinstance(func, collections.Callable)
 
 
+def parse_packages_args(packages):
+    search_text = ''
+    app = None
+
+    # avoid treating strings as sequences ('foo' should not be 'f', 'o', 'o')
+    if isinstance(packages, basestring):
+        packages = (packages,)
+
+    if not isinstance(packages, collections.Iterable):
+        LOG.warning('show_available_packages: argument is not an iterable %r',
+            packages)
+        return search_text, app
+
+    items = []  # make a copy of the given sequence
+    for arg in packages:
+        # support both "pkg1 pkg" and "pkg1,pkg2" (and "pkg1,pkg2 pkg3")
+        if "," in arg:
+            items.extend(arg.split(SearchSeparators.PACKAGE))
+        else:
+            items.append(arg)
+
+    if len(items) > 0:
+        # allow s-c to be called with a search term
+        if items[0].startswith(SEARCH_PREFIX):
+            # remove the initial search prefix
+            items[0] = items[0].replace(SEARCH_PREFIX, '', 1)
+            search_text = SearchSeparators.REGULAR.join(items)
+        else:
+            # strip away the initial apt: prefix, if present
+            items[0] = re.sub(PACKAGE_PREFIX_REGEX, '', items[0])
+            if len(items) > 1:
+                # turn multiple packages into a search with "," as separator
+                search_text = SearchSeparators.PACKAGE.join(items)
+
+    if not search_text and len(items) == 1:
+        request = items[0]
+        # are we dealing with a path?
+        if os.path.exists(request) and not os.path.isdir(request):
+            if not request.startswith('/'):
+                # we may have been given a relative path
+                request = os.path.abspath(request)
+            # will raise DebOpenFileError if request is invalid
+            app = DebFileApplication(request)
+        else:
+            # package from archive
+            # if there is a "/" in the string consider it as tuple
+            # of (pkgname, appname) for exact matching (used by
+            # e.g. unity
+            (pkgname, sep, appname) = request.partition("/")
+            if pkgname or appname:
+                app = Application(appname, pkgname)
+            else:
+                LOG.warning('show_available_packages: received %r but '
+                    'can not build an Application from it.', request)
+
+    return search_text, app
+
+
 class SoftwarecenterDbusController(dbus.service.Object):
     """
     This is a helper to provide the SoftwarecenterIFace
@@ -158,13 +232,16 @@
     # the size of the icon for dialogs
     APP_ICON_SIZE = Gtk.IconSize.DIALOG
 
+    START_DBUS = True
+
     def __init__(self, datadir, xapian_base_path, options, args=None):
-        # setup dbus and exit if there is another instance already
-        # running
-        self.setup_dbus_or_bring_other_instance_to_front(args)
+        self.dbusControler = None
+        if self.START_DBUS:
+            # setup dbus and exit if there is another instance already running
+            self.setup_dbus_or_bring_other_instance_to_front(args)
 
         self.datadir = datadir
-        SimpleGtkbuilderApp.__init__(self,
+        super(SoftwareCenterAppGtk3, self).__init__(
                                      datadir + "/ui/gtk3/SoftwareCenter.ui",
                                      "software-center")
         gettext.bindtextdomain("software-center", "/usr/share/locale")
@@ -525,6 +602,18 @@
     def on_review_stats_loaded(self, reviews):
         LOG.debug("on_review_stats_loaded: '%s'" % len(reviews))
 
+    def destroy(self):
+        """Destroy this instance and every used resource."""
+        self.window_main.destroy()
+
+        # remove global instances of Managers
+        self.app_manager.destroy()
+        self.view_manager.destroy()
+
+        if self.dbusControler is not None:
+            # ensure that the dbus controller is really gone
+            self.dbusControler.stop()
+
     def close_app(self):
         """ perform tasks like save-state etc when the application is
             exited
@@ -539,15 +628,14 @@
         if hasattr(self, "glaunchpad"):
             self.glaunchpad.shutdown()
         self.save_state()
+        self.destroy()
+
         # this will not throw exceptions in pygi but "only" log via g_critical
         # to the terminal but it might in the future so we add a handler here
         try:
             Gtk.main_quit()
         except:
             LOG.exception("Gtk.main_quit failed")
-        # ensure that the dbus controller is really gone, just for good
-        # measure
-        self.dbusControler.stop()
         # exit here explictely to ensure that no further gtk event loops or
         # threads run and cause havoc on exit (LP: #914393)
         sys.exit(0)
@@ -1217,75 +1305,49 @@
             bus_name = dbus.service.BusName('com.ubuntu.Softwarecenter', bus)
             self.dbusControler = SoftwarecenterDbusController(self, bus_name)
 
+    @wait_for_apt_cache_ready
+    def show_app(self, app):
+        """Show 'app' in the installed pane if is installed.
+
+        If 'app' is not installed, show it in the available pane.
+
+        """
+        if (app.pkgname in self.cache and self.cache[app.pkgname].installed):
+            with ExecutionTime("installed_pane.init_view()"):
+                self.installed_pane.init_view()
+            with ExecutionTime("installed_pane.show_app()"):
+                self.installed_pane.show_app(app)
+        else:
+            self.available_pane.init_view()
+            self.available_pane.show_app(app)
+
     def show_available_packages(self, packages):
         """ Show packages given as arguments in the available_pane
             If the list of packages is only one element long show that,
             otherwise turn it into a comma seperated search
         """
-        # strip away the apt: prefix
-        if packages and packages[0].startswith("apt:///"):
-            # this is for 'apt:pkgname' in alt+F2 in gnome
-            packages[0] = packages[0].partition("apt:///")[2]
-        elif packages and packages[0].startswith("apt://"):
-            packages[0] = packages[0].partition("apt://")[2]
-        elif packages and packages[0].startswith("apt:"):
-            packages[0] = packages[0].partition("apt:")[2]
-
-        # allow s-c to be called with a search term
-        if packages and packages[0].startswith("search:"):
-            packages[0] = packages[0].partition("search:")[2]
-            self.available_pane.init_view()
-            self.available_pane.searchentry.set_text(" ".join(packages))
-            return
-
-        if len(packages) == 1:
-            request = packages[0]
-
-            # are we dealing with a path?
-            if os.path.exists(request) and not os.path.isdir(request):
-                if not request.startswith('/'):
-                # we may have been given a relative path
-                    request = os.path.join(os.getcwd(), request)
-                try:
-                    app = DebFileApplication(request)
-                except ValueError as e:
-                    LOG.error("can not open %s: %s" % (request, e))
-                    from softwarecenter.ui.gtk3.dialogs import error
-                    error(None,
+        try:
+            search_text, app = parse_packages_args(packages)
+        except DebFileOpenError as e:
+            LOG.exception("show_available_packages: can not open %r, error:",
+                          packages)
+            dialogs.error(None,
                           _("Error"),
-                          _("The file “%s” could not be opened.") % request)
-                    app = None
-            else:
-                # package from archive
-                # if there is a "/" in the string consider it as tuple
-                # of (pkgname, appname) for exact matching (used by
-                # e.g. unity
-                (pkgname, sep, appname) = packages[0].partition("/")
-                app = Application(appname, pkgname)
-
-            @wait_for_apt_cache_ready
-            def show_app(self, app):
-                # if the pkg is installed, show it in the installed pane
-                if (app.pkgname in self.cache and
-                    self.cache[app.pkgname].installed):
-                    with ExecutionTime("installed_pane.init_view()"):
-                        self.installed_pane.init_view()
-                    with ExecutionTime("installed_pane.show_app()"):
-                        self.installed_pane.show_app(app)
-                else:
-                    self.available_pane.init_view()
-                    self.available_pane.show_app(app)
-            if app:
-                show_app(self, app)
-                return
-        elif len(packages) > 1:
-            # turn multiple packages into a search with ","
+                          _("The file “%s” could not be opened.") % e.path)
+            search_text = app = None
+
+        LOG.info('show_available_packages: search_text is %r, app is %r.',
+                 search_text, app)
+
+        if search_text:
             self.available_pane.init_view()
-            self.available_pane.searchentry.set_text(",".join(packages))
-            return
-        # normal startup, show the lobby (it will have a spinner when
-        # its not ready yet) - it will also initialize the view
-        self.view_manager.set_active_view(ViewPages.AVAILABLE)
+            self.available_pane.searchentry.set_text(search_text)
+        elif app is not None:
+            self.show_app(app)
+        else:
+            # normal startup, show the lobby (it will have a spinner when
+            # its not ready yet) - it will also initialize the view
+            self.view_manager.set_active_view(ViewPages.AVAILABLE)
 
     def restore_state(self):
         if self.config.has_option("general", "size"):

=== modified file 'softwarecenter/ui/gtk3/models/appstore2.py'
--- softwarecenter/ui/gtk3/models/appstore2.py	2012-05-18 05:47:10 +0000
+++ softwarecenter/ui/gtk3/models/appstore2.py	2012-05-21 15:37:20 +0000
@@ -164,6 +164,7 @@
         if doc.installed is None:
             pkgname = self.get_pkgname(doc)
             doc.installed = (self.is_available(doc) and
+                             pkgname in self.cache and
                              self.cache[pkgname].is_installed)
         return doc.installed
 

=== modified file 'softwarecenter/ui/gtk3/session/appmanager.py'
--- softwarecenter/ui/gtk3/session/appmanager.py	2012-03-15 00:16:03 +0000
+++ softwarecenter/ui/gtk3/session/appmanager.py	2012-05-21 15:37:20 +0000
@@ -71,6 +71,11 @@
         else:
             _appmanager = self
 
+    def destroy(self):
+        """Destroy the global instance."""
+        global _appmanager
+        _appmanager = None
+
     def request_action(self, app, addons_install, addons_remove, action):
         """callback when an app action is requested from the appview,
            if action is "remove", must check if other dependencies have to be

=== modified file 'softwarecenter/ui/gtk3/session/viewmanager.py'
--- softwarecenter/ui/gtk3/session/viewmanager.py	2012-03-15 00:16:03 +0000
+++ softwarecenter/ui/gtk3/session/viewmanager.py	2012-05-21 15:37:20 +0000
@@ -69,6 +69,11 @@
         else:
             _viewmanager = self
 
+    def destroy(self):
+        """Destroy the global instance."""
+        global _viewmanager
+        _viewmanager = None
+
     def on_search_terms_changed(self, widget, new_text):
         pane = self.get_current_view_widget()
         if hasattr(pane, "on_search_terms_changed"):

=== modified file 'softwarecenter/ui/gtk3/views/appdetailsview.py'
--- softwarecenter/ui/gtk3/views/appdetailsview.py	2012-05-14 03:16:07 +0000
+++ softwarecenter/ui/gtk3/views/appdetailsview.py	2012-05-21 15:37:20 +0000
@@ -1738,7 +1738,7 @@
             # update all (but skip the addons calculation if this is a
             # DebFileApplication as this is not useful for this case and it
             # increases the view load time dramatically)
-            skip_update_addons = type(self.app) == DebFileApplication
+            skip_update_addons = isinstance(self.app, DebFileApplication)
             self._update_all(self.app_details,
                              skip_update_addons=skip_update_addons)
 
@@ -2013,7 +2013,7 @@
             self.addons_manager.addons_to_remove,
             self.app.archive_suite)
         total_download_size, total_install_size = res
-        if res == (0, 0) and type(self.app) == DebFileApplication:
+        if res == (0, 0) and isinstance(self.app, DebFileApplication):
             total_install_size = self.app_details.installed_size
         if total_download_size > 0:
             download_size = GLib.format_size(total_download_size)

=== modified file 'softwarecenter/ui/gtk3/widgets/videoplayer.py'
--- softwarecenter/ui/gtk3/widgets/videoplayer.py	2012-03-08 17:42:36 +0000
+++ softwarecenter/ui/gtk3/widgets/videoplayer.py	2012-05-21 15:37:20 +0000
@@ -72,7 +72,11 @@
     # uri property
     def _set_uri(self, v):
         self._uri = v or ""
-        self.webkit.load_uri(self._uri)
+        if self._uri:
+            # only load the uri if it's defined, otherwise we may get:
+            # Program received signal SIGSEGV, Segmentation fault.
+            # webkit_web_frame_load_uri () from /usr/lib/libwebkitgtk-3.0.so.0
+            self.webkit.load_uri(self._uri)
 
     def _get_uri(self):
         return self._uri

=== added file 'test/gtk3/__init__.py'
=== added file 'test/gtk3/test_app.py'
--- test/gtk3/test_app.py	1970-01-01 00:00:00 +0000
+++ test/gtk3/test_app.py	2012-05-21 15:37:20 +0000
@@ -0,0 +1,357 @@
+#!/usr/bin/python
+
+import os
+import unittest
+
+from collections import defaultdict
+from functools import partial
+
+from mock import Mock
+
+from testutils import get_mock_options, setup_test_env
+setup_test_env()
+
+import softwarecenter.paths
+from softwarecenter.db import DebFileApplication, DebFileOpenError
+from softwarecenter.enums import PkgStates, SearchSeparators
+from softwarecenter.ui.gtk3 import app
+
+
+class FakedCache(dict):
+    """A faked cache."""
+
+    def __init__(self, *a, **kw):
+        super(FakedCache, self).__init__()
+        self._callbacks = defaultdict(list)
+        self.ready = False
+
+    def open(self):
+        """Open this cache."""
+        self.ready = True
+
+    def connect(self, signal, callback):
+        """Connect a signal with a callback."""
+        self._callbacks[signal].append(callback)
+
+    def disconnect_by_func(self, callback):
+        """Disconnect 'callback' from every signal."""
+        for signal, cb in self._callbacks.iteritems():
+            if cb == callback:
+                self._callbacks[signal].remove(callback)
+            if len(self._callbacks[signal]) == 0:
+                self._callbacks.pop(signal)
+
+    def get_addons(self, pkgname):
+        """Return (recommended, suggested) addons for 'pkgname'."""
+        return ([],[])
+
+    def get_total_size_on_install(self,pkgname, addons_to_install,
+                                  addons_to_remove, archive_suite):
+        """Return a fake (total_download_size, total_install_size) result."""
+        return (0, 0)
+
+
+class ParsePackagesArgsTestCase(unittest.TestCase):
+    """Test suite for the parse_packages_args helper."""
+
+    pkg_name = 'foo'
+
+    def transform_for_test(self, items):
+        """Transform a sequence into a comma separated string."""
+        return app.SEARCH_PREFIX + SearchSeparators.REGULAR.join(items)
+
+    def do_check(self, apps, items=None):
+        """Check that the available_pane was shown."""
+        if items is None:
+            items = self.transform_for_test(apps)
+
+        search_text, result_app = app.parse_packages_args(items)
+
+        self.assertEqual(SearchSeparators.REGULAR.join(apps), search_text)
+        self.assertIsNone(result_app)
+
+    def test_empty(self):
+        """Pass an empty argument, show the 'available' view."""
+        self.do_check(apps=())
+
+    def test_single_empty_item(self):
+        """Pass a single empty item, show the 'available' view."""
+        self.do_check(apps=('',))
+
+    def test_single_item(self):
+        """Pass a single item, show the 'available' view."""
+        self.do_check(apps=(self.pkg_name,))
+
+    def test_two_items(self):
+        """Pass two items, show the 'available' view."""
+        self.do_check(apps=(self.pkg_name, 'bar'))
+
+    def test_several_items(self):
+        """Pass several items, show the 'available' view."""
+        self.do_check(apps=(self.pkg_name, 'firefox', 'software-center'))
+
+
+class ParsePackageArgsAsFileTestCase(unittest.TestCase):
+
+    def test_item_is_a_file(self):
+        """Pass an item that is an existing file."""
+        # pass a real deb here
+        fname = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                             "..", "data", "test_debs", "gdebi-test1.deb")
+        assert os.path.exists(fname)
+        # test once as string and as list
+        for items in ( fname, [fname] ):
+            search_text, result_app = app.parse_packages_args(fname)
+            self.assertIsInstance(result_app, DebFileApplication)
+
+    def test_item_is_invalid_file(self):
+        """ Pass an invalid file item """
+        fname = __file__
+        assert os.path.exists(fname)
+        self.assertRaises(DebFileOpenError, app.parse_packages_args, fname)
+        
+
+class ParsePackagesWithAptPrefixTestCase(ParsePackagesArgsTestCase):
+
+    installed = None
+
+    def setUp(self):
+        super(ParsePackagesWithAptPrefixTestCase, self).setUp()
+
+        self.cache = FakedCache()
+        self.db = app.StoreDatabase(cache=self.cache)
+
+        assert self.pkg_name not in self.cache
+        if self.installed is not None:
+            mock_cache_entry = Mock()
+            mock_cache_entry.website = None
+            mock_cache_entry.license = None
+            mock_cache_entry.installed_files = []
+            mock_cache_entry.candidate = Mock()
+            mock_cache_entry.candidate.version = '1.0'
+            mock_cache_entry.candidate.description = 'A nonsense app.'
+            mock_cache_entry.candidate.origins = ()
+            mock_cache_entry.versions = (Mock(),)
+            mock_cache_entry.versions[0].version = '0.99'
+            mock_cache_entry.versions[0].origins = (Mock(),)
+            mock_cache_entry.versions[0].origins[0].archive = 'test'
+            mock_cache_entry.is_installed = self.installed
+            if self.installed:
+                mock_cache_entry.installed = Mock()
+                mock_cache_entry.installed.version = '0.90'
+                mock_cache_entry.installed.installed_size = 0
+            else:
+                mock_cache_entry.installed = None
+
+            self.cache[self.pkg_name] = mock_cache_entry
+            self.addCleanup(self.cache.pop, self.pkg_name)
+
+
+    def transform_for_test(self, items):
+        """Do nothing."""
+        return items
+
+    def check_package_availability(self, name):
+        """Check whether the package 'name' is available."""
+        if name not in self.cache:
+            state = PkgStates.NOT_FOUND
+        elif self.cache[name].installed:
+            state = PkgStates.INSTALLED
+        else:
+            state = PkgStates.UNINSTALLED
+        return state
+
+    def do_check(self, apps, items=None):
+        """Check that the available_pane was shown."""
+        if items is None:
+            items = self.transform_for_test(apps)
+
+        search_text, result_app = app.parse_packages_args(items)
+
+        if apps and len(apps) == 1 and apps[0] and not os.path.isfile(apps[0]):
+            self.assertIsNotNone(result_app)
+            app_details = result_app.get_details(self.db)
+
+            self.assertEqual(apps[0], app_details.name)
+            state = self.check_package_availability(app_details.name)
+            self.assertEqual(state, app_details.pkg_state)
+        else:
+            self.assertIsNone(result_app)
+
+        if apps and (len(apps) > 1 or os.path.isfile(apps[0])):
+            self.assertEqual(SearchSeparators.PACKAGE.join(apps), search_text)
+        else:
+            self.assertEqual('', search_text)
+
+    def test_item_with_prefix(self):
+        """Pass a item with the item prefix."""
+        for prefix in ('apt:', 'apt://', 'apt:///'):
+            for case in (self.pkg_name, app.PACKAGE_PREFIX + self.pkg_name):
+                self.do_check(apps=(case,), items=(prefix + case,))
+
+
+class ParsePackagesNotInstalledTestCase(ParsePackagesWithAptPrefixTestCase):
+    """Test suite for parsing/searching/loading package lists."""
+
+    installed = False
+
+
+class ParsePackagesInstalledTestCase(ParsePackagesWithAptPrefixTestCase):
+    """Test suite for parsing/searching/loading package lists."""
+
+    installed = True
+
+
+class ParsePackagesArgsStringTestCase(ParsePackagesWithAptPrefixTestCase):
+    """Test suite for parsing/loading package lists from strings."""
+
+    def transform_for_test(self, items):
+        """Transform a sequence into a comma separated string."""
+        return SearchSeparators.PACKAGE.join(items)
+
+
+class AppTestCase(unittest.TestCase):
+    """Test suite for the app module."""
+
+    def setUp(self):
+        super(AppTestCase, self).setUp()
+        self.called = defaultdict(list)
+        self.addCleanup(self.called.clear)
+
+        orig = app.SoftwareCenterAppGtk3.START_DBUS
+        self.addCleanup(setattr, app.SoftwareCenterAppGtk3, 'START_DBUS', orig)
+        app.SoftwareCenterAppGtk3.START_DBUS = False
+
+        orig = app.get_pkg_info
+        self.addCleanup(setattr, app, 'get_pkg_info', orig)
+        app.get_pkg_info = lambda: FakedCache()
+
+        datadir = softwarecenter.paths.datadir
+        xapianpath = softwarecenter.paths.XAPIAN_BASE_PATH
+        options = get_mock_options()
+        self.app = app.SoftwareCenterAppGtk3(datadir, xapianpath, options)
+        self.addCleanup(self.app.destroy)
+
+        self.app.cache.open()
+
+        # connect some signals of interest
+        cid = self.app.installed_pane.connect('installed-pane-created',
+                partial(self.track_calls, 'pane-created'))
+        self.addCleanup(self.app.installed_pane.disconnect, cid)
+
+        cid = self.app.available_pane.connect('available-pane-created',
+                partial(self.track_calls, 'pane-created'))
+        self.addCleanup(self.app.available_pane.disconnect, cid)
+
+    def track_calls(self, name, *a, **kw):
+        """Record the callback for 'name' using 'args' and 'kwargs'."""
+        self.called[name].append((a, kw))
+
+
+class ShowPackagesTestCase(AppTestCase):
+    """Test suite for parsing/searching/loading package lists."""
+
+    def do_check(self, packages, search_text):
+        """Check that the available_pane was shown."""
+        self.app.show_available_packages(packages=packages)
+
+        self.assertEqual(self.called,
+            {'pane-created': [((self.app.available_pane,), {})]})
+
+        actual = self.app.available_pane.searchentry.get_text()
+        self.assertEqual(search_text, actual,
+            'Expected search text %r (got %r instead) for packages %r.' %
+            (search_text, actual, packages))
+
+        self.assertIsNone(self.app.available_pane.app_details_view.app_details)
+
+    def test_show_available_packages_search_prefix(self):
+        """Check that the available_pane was shown."""
+        self.do_check(packages='search:foo,bar baz', search_text='foo bar baz')
+
+    def test_show_available_packages_apt_prefix(self):
+        """Check that the available_pane was shown."""
+        for prefix in ('apt:', 'apt://', 'apt:///'):
+            self.do_check(packages=prefix + 'foo,bar,baz',
+                          search_text='foo,bar,baz')
+
+
+class ShowPackagesOnePackageTestCase(AppTestCase):
+    """Test suite for parsing/searching/loading package lists."""
+
+    pkg_name = 'foo'
+    installed = None
+
+    def setUp(self):
+        super(ShowPackagesOnePackageTestCase, self).setUp()
+        assert self.pkg_name not in self.app.cache
+        if self.installed is not None:
+            mock_cache_entry = Mock()
+            mock_cache_entry.website = None
+            mock_cache_entry.license = None
+            mock_cache_entry.installed_files = []
+            mock_cache_entry.candidate = Mock()
+            mock_cache_entry.candidate.version = '1.0'
+            mock_cache_entry.candidate.description = 'A nonsense app.'
+            mock_cache_entry.candidate.origins = ()
+            mock_cache_entry.versions = (Mock(),)
+            mock_cache_entry.versions[0].version = '0.99'
+            mock_cache_entry.versions[0].origins = (Mock(),)
+            mock_cache_entry.versions[0].origins[0].archive = 'test'
+            mock_cache_entry.is_installed = self.installed
+            if self.installed:
+                mock_cache_entry.installed = Mock()
+                mock_cache_entry.installed.version = '0.90'
+                mock_cache_entry.installed.installed_size = 0
+            else:
+                mock_cache_entry.installed = None
+
+            self.app.cache[self.pkg_name] = mock_cache_entry
+            self.addCleanup(self.app.cache.pop, self.pkg_name)
+
+    def check_package_availability(self, name):
+        """Check whether the package 'name' is available."""
+        pane = self.app.available_pane
+        if name not in self.app.cache:
+            state = PkgStates.NOT_FOUND
+        elif self.app.cache[name].installed:
+            state = PkgStates.INSTALLED
+            pane = self.app.installed_pane
+        else:
+            state = PkgStates.UNINSTALLED
+
+        self.assertEqual(state, pane.app_details_view.app_details.pkg_state)
+
+        return pane
+
+    def test_show_available_packages(self):
+        """Check that the available_pane was shown."""
+        self.app.show_available_packages(packages=self.pkg_name)
+
+        expected_pane = self.check_package_availability(self.pkg_name)
+        name = expected_pane.app_details_view.app_details.name
+        self.assertEqual(self.pkg_name, name)
+
+        self.assertEqual('', self.app.available_pane.searchentry.get_text())
+
+        self.assertEqual(self.called,
+            {'pane-created': [((expected_pane,), {})]})
+
+
+class ShowPackagesNotInstalledTestCase(ShowPackagesOnePackageTestCase):
+    """Test suite for parsing/searching/loading package lists."""
+
+    installed = False
+
+
+class ShowPackagesInstalledTestCase(ShowPackagesOnePackageTestCase):
+    """Test suite for parsing/searching/loading package lists."""
+
+    installed = True
+
+
+if __name__ == "__main__":
+    # avoid spawning recommender-agent, reviews, software-center-agent etc,
+    # cuts ~5s or so
+    os.environ["SOFTWARE_CENTER_DISABLE_SPAWN_HELPER"] = "1"
+    unittest.main()

=== modified file 'test/gtk3/test_debfile_view.py'
--- test/gtk3/test_debfile_view.py	2012-02-23 16:40:27 +0000
+++ test/gtk3/test_debfile_view.py	2012-05-21 15:37:20 +0000
@@ -3,22 +3,18 @@
 import time
 import unittest
 
-from mock import Mock
-
-from testutils import setup_test_env, do_events
+from testutils import do_events, get_mock_options, setup_test_env
 setup_test_env()
 
 import softwarecenter.paths
 from softwarecenter.ui.gtk3.app import SoftwareCenterAppGtk3
 from softwarecenter.ui.gtk3.panes.availablepane import AvailablePane
 
+
 class DebFileOpenTestCase(unittest.TestCase):
 
     def test_deb_file_view_error(self):
-        mock_options = Mock()
-        mock_options.display_navlog = False
-        mock_options.disable_apt_xapian_index = False
-        mock_options.disable_buy = False
+        mock_options = get_mock_options()
         xapianpath = softwarecenter.paths.XAPIAN_BASE_PATH
         app = SoftwareCenterAppGtk3(
             softwarecenter.paths.datadir, xapianpath, mock_options)
@@ -37,7 +33,6 @@
         # this is deb that is not installable
         action_button = app.available_pane.app_details_view.pkg_statusbar.button
         self.assertFalse(action_button.get_property("visible"))
-        
 
 
 if __name__ == "__main__":

=== modified file 'test/gtk3/test_purchase.py'
--- test/gtk3/test_purchase.py	2012-03-19 14:38:10 +0000
+++ test/gtk3/test_purchase.py	2012-05-21 15:37:20 +0000
@@ -3,12 +3,12 @@
 import time
 import unittest
 
-from mock import Mock,patch
+from mock import Mock, patch
 
 from testutils import setup_test_env
 setup_test_env()
 
-from softwarecenter.testutils import do_events
+from softwarecenter.testutils import do_events, get_mock_options
 from softwarecenter.ui.gtk3.app import SoftwareCenterAppGtk3
 from softwarecenter.ui.gtk3.panes.availablepane import AvailablePane
 import softwarecenter.paths
@@ -35,7 +35,7 @@
         self.assertTrue("skipping" in mock.debug.call_args[0][0])
         self.assertFalse("consumer_secret" in mock.debug.call_args[0][0])
         mock.reset_mock()
-        
+
         # run another one
         win.destroy()
 
@@ -71,25 +71,21 @@
         # run another one
         win.destroy()
 
-
     def test_reinstall_previous_purchase_display(self):
-        mock_options = Mock()
-        mock_options.display_navlog = False
-        mock_options.disable_apt_xapian_index = False
-        mock_options.disable_buy = False
+        mock_options = get_mock_options()
         xapiandb = "/var/cache/software-center/"
         app = SoftwareCenterAppGtk3(
             softwarecenter.paths.datadir, xapiandb, mock_options)
-	# real app opens cache async
-	app.cache.open()
-	# show it
+        # real app opens cache async
+        app.cache.open()
+        # show it
         app.window_main.show_all()
         app.available_pane.init_view()
         self._p()
         app.on_menuitem_reinstall_purchases_activate(None)
         # it can take a bit until the sso client is ready
         for i in range(100):
-            if (app.available_pane.get_current_page() == 
+            if (app.available_pane.get_current_page() ==
                 AvailablePane.Pages.LIST):
                 break
             self._p()

=== modified file 'test/test_database.py'
--- test/test_database.py	2012-04-13 16:32:26 +0000
+++ test/test_database.py	2012-05-21 15:37:20 +0000
@@ -406,9 +406,13 @@
 packagesize	3	# package size
 app-popcon	4	# app-install .desktop popcon rank
 """
-        open("axi-test-values","w").write(s)
+        fname = "axi-test-values"
+        with open(fname, "w") as f:
+            f.write(s)
+        self.addCleanup(os.remove, fname)
+
         #db = StoreDatabase("/var/cache/software-center/xapian", self.cache)
-        axi_values = parse_axi_values_file("axi-test-values")
+        axi_values = parse_axi_values_file(fname)
         self.assertNotEqual(axi_values, {})
         print axi_values
 
@@ -428,7 +432,8 @@
                            nonblocking_load=False)
         self.assertTrue(len(enquirer.get_docids()) > 0)
         # FIXME: test more of the interface
-        
+
+
 class UtilsTestCase(unittest.TestCase):
 
     def test_utils_get_installed_package_list(self):

=== modified file 'test/test_debfileapplication.py'
--- test/test_debfileapplication.py	2012-02-23 16:40:27 +0000
+++ test/test_debfileapplication.py	2012-05-21 15:37:20 +0000
@@ -7,7 +7,7 @@
 setup_test_env()
 
 from softwarecenter.enums import PkgStates
-from softwarecenter.db.debfile import DebFileApplication
+from softwarecenter.db.debfile import DebFileApplication, DebFileOpenError
 from softwarecenter.testutils import get_test_db
 
 DEBFILE_PATH = './data/test_debs/gdebi-test9.deb'
@@ -22,6 +22,7 @@
 DEBFILE_PATH_CORRUPT = './data/test_debs/corrupt.deb'
 DEBFILE_NOT_INSTALLABLE = './data/test_debs/gdebi-test1.deb'
 
+
 class TestDebFileApplication(unittest.TestCase):
     """ Test the class DebFileApplication """
 
@@ -31,7 +32,7 @@
     def test_get_name(self):
         debfileapplication = DebFileApplication(DEBFILE_PATH)
         debfiledetails = debfileapplication.get_details(self.db)
-        
+
         self.assertEquals(debfiledetails.name, DEBFILE_NAME)
 
     def test_get_description(self):
@@ -64,9 +65,10 @@
         debfileapplication = DebFileApplication(DEBFILE_PATH_NOTFOUND)
         debfiledetails = debfileapplication.get_details(self.db)
         self.assertEquals(debfiledetails.pkg_state, PkgStates.NOT_FOUND)
-        
+
     def test_get_pkg_state_not_a_deb(self):
-        self.assertRaises(ValueError, DebFileApplication, DEBFILE_PATH_NOTADEB)
+        self.assertRaises(DebFileOpenError,
+                          DebFileApplication, DEBFILE_PATH_NOTADEB)
 
     def test_get_pkg_state_corrupt(self):
         debfileapplication = DebFileApplication(DEBFILE_PATH_CORRUPT)
@@ -87,12 +89,14 @@
         debfileapplication = DebFileApplication(DEBFILE_PATH)
         debfiledetails = debfileapplication.get_details(self.db)
         self.assertEquals(debfiledetails.installed_size, 0)
-        
+
     def test_get_warning(self):
         debfileapplication = DebFileApplication(DEBFILE_PATH)
         debfiledetails = debfileapplication.get_details(self.db)
         self.assertEquals(debfiledetails.warning, DEBFILE_WARNING)
-        
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
     unittest.main()
+