def test_package_states(self): db = xapian.WritableDatabase("./data/test.db", xapian.DB_CREATE_OR_OVERWRITE) res = update_from_app_install_data(db, self.cache, datadir="./data/desktop") self.assertTrue(res) db = StoreDatabase("./data/test.db", self.cache) db.open(use_axi=False) # test PkgStates.INSTALLED # FIXME: this will only work if software-center is installed app = Application("Ubuntu Software Center Test", "software-center") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.INSTALLED) # test PkgStates.UNINSTALLED # test PkgStates.UPGRADABLE # test PkgStates.REINSTALLABLE # test PkgStates.INSTALLING # test PkgStates.REMOVING # test PkgStates.UPGRADING # test PkgStates.NEEDS_SOURCE app = Application("Zynjacku Test", "zynjacku-fake") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.NEEDS_SOURCE) # test PkgStates.NEEDS_PURCHASE app = Application("The expensive gem", "expensive-gem") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.NEEDS_PURCHASE) self.assertEqual(appdetails.icon_url, "http://www.google.com/favicon.ico") self.assertEqual(appdetails.icon, "favicon") # test PkgStates.PURCHASED_BUT_REPO_MUST_BE_ENABLED # test PkgStates.UNKNOWN app = Application("Scintillant Orange", "scintillant-orange") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.NOT_FOUND)
def get_test_catview(): def on_category_selected(view, cat): print("on_category_selected %s %s" % view, cat) from softwarecenter.db.pkginfo import get_pkg_info cache = get_pkg_info() cache.open() from softwarecenter.db.database import StoreDatabase xapian_base_path = "/var/cache/software-center" pathname = os.path.join(xapian_base_path, "xapian") db = StoreDatabase(pathname, cache) db.open() import softwarecenter.paths datadir = softwarecenter.paths.datadir from softwarecenter.ui.gtk3.utils import get_sc_icon_theme icons = get_sc_icon_theme(datadir) import softwarecenter.distro distro = softwarecenter.distro.get_distro() apps_filter = AppFilter(db, cache) from softwarecenter.paths import APP_INSTALL_PATH cat_view = LobbyViewGtk(datadir, APP_INSTALL_PATH, cache, db, icons, distro, apps_filter) return cat_view
def test_packagename_is_application(self): db = StoreDatabase("/var/cache/software-center/xapian", self.cache) db.open() # apt has no app self.assertEqual(db.get_apps_for_pkgname("apt"), set()) # but software-center has self.assertEqual(len(db.get_apps_for_pkgname("software-center")), 1)
def get_test_window(): import softwarecenter.log softwarecenter.log.root.setLevel(level=logging.DEBUG) softwarecenter.log.add_filters_from_string("performance") fmt = logging.Formatter("%(name)s - %(message)s", None) softwarecenter.log.handler.setFormatter(fmt) from softwarecenter.paths import XAPIAN_BASE_PATH xapian_base_path = XAPIAN_BASE_PATH pathname = os.path.join(xapian_base_path, "xapian") # the store from softwarecenter.db.pkginfo import get_pkg_info cache = get_pkg_info() cache.open() # the db from softwarecenter.db.database import StoreDatabase db = StoreDatabase(pathname, cache) db.open() # additional icons come from app-install-data icons = Gtk.IconTheme.get_default() icons.prepend_search_path("/usr/share/app-install/icons/") icons.prepend_search_path("/usr/share/software-center/icons/") # create a filter from softwarecenter.db.appfilter import AppFilter filter = AppFilter(db, cache) filter.set_supported_only(False) filter.set_installed_only(True) # appview from softwarecenter.ui.gtk3.models.appstore2 import AppListStore from softwarecenter.db.enquire import AppEnquire enquirer = AppEnquire(cache, db) store = AppListStore(db, cache, icons) from softwarecenter.ui.gtk3.views.appview import AppView view = AppView(db, cache, icons, show_ratings=True) view.set_model(store) entry = Gtk.Entry() entry.stamp = 0 entry.connect("changed", on_entry_changed, (view, enquirer)) entry.set_text("gtk3") scroll = Gtk.ScrolledWindow() box = Gtk.VBox() box.pack_start(entry, False, True, 0) box.pack_start(scroll, True, True, 0) win = Gtk.Window() win.connect("destroy", lambda x: Gtk.main_quit()) scroll.add(view) win.add(box) win.set_size_request(600, 400) win.show_all() return win
def setUp(self): cache = get_pkg_info() cache.open() xapian_base_path = XAPIAN_BASE_PATH pathname = os.path.join(xapian_base_path, "xapian") self.db = StoreDatabase(pathname, cache) self.db.open()
def test_app_enquire(self): db = StoreDatabase(cache=self.cache) db.open() # test the AppEnquire engine enquirer = AppEnquire(self.cache, db) enquirer.set_query(xapian.Query("a"), nonblocking_load=False) self.assertTrue(len(enquirer.get_docids()) > 0)
def test_reinstall_purchased_xapian(self): db = StoreDatabase("/var/cache/software-center/xapian", self.cache) db.open(use_axi=False) # now create purchased debs xapian index (in memory because # we store the repository passwords in here) old_db_len = len(db) query = add_from_purchased_but_needs_reinstall_data( self.available_to_me, db, self.cache) # ensure we have a new item (the available for reinstall one) self.assertEqual(len(db), old_db_len + 1) # query enquire = xapian.Enquire(db.xapiandb) enquire.set_query(query) matches = enquire.get_mset(0, len(db)) self.assertEqual(len(matches), 1) for m in matches: doc = db.xapiandb.get_document(m.docid) self.assertEqual(doc.get_value(XapianValues.PKGNAME), "photobomb") self.assertEqual( doc.get_value(XapianValues.ARCHIVE_SIGNING_KEY_ID), "1024R/75254D99") self.assertEqual( doc.get_value(XapianValues.ARCHIVE_DEB_LINE), "deb https://username:random3atoken@" "private-ppa.launchpad.net/commercial-ppa-uploaders" "/photobomb/ubuntu precise main")
def get_test_window_catview(): def on_category_selected(view, cat): print("on_category_selected %s %s" % view, cat) from softwarecenter.db.pkginfo import get_pkg_info cache = get_pkg_info() cache.open() from softwarecenter.db.database import StoreDatabase xapian_base_path = "/var/cache/software-center" pathname = os.path.join(xapian_base_path, "xapian") db = StoreDatabase(pathname, cache) db.open() import softwarecenter.paths datadir = softwarecenter.paths.datadir from softwarecenter.ui.gtk3.utils import get_sc_icon_theme icons = get_sc_icon_theme(datadir) import softwarecenter.distro distro = softwarecenter.distro.get_distro() apps_filter = AppFilter(db, cache) # gui win = Gtk.Window() n = Gtk.Notebook() from softwarecenter.paths import APP_INSTALL_PATH view = LobbyViewGtk(datadir, APP_INSTALL_PATH, cache, db, icons, distro, apps_filter) win.set_data("lobby", view) scroll = Gtk.ScrolledWindow() scroll.add(view) n.append_page(scroll, Gtk.Label(label="Lobby")) # find a cat in the LobbyView that has subcategories subcat_cat = None for cat in reversed(view.categories): if cat.subcategories: subcat_cat = cat break view = SubCategoryViewGtk(datadir, APP_INSTALL_PATH, cache, db, icons, apps_filter) view.connect("category-selected", on_category_selected) view.set_subcategory(subcat_cat) win.set_data("subcat", view) scroll = Gtk.ScrolledWindow() scroll.add(view) n.append_page(scroll, Gtk.Label(label="Subcats")) win.add(n) win.set_size_request(800, 600) win.show_all() win.connect('destroy', Gtk.main_quit) return win
def get_test_window_pkgnamesview(): from softwarecenter.db.pkginfo import get_pkg_info cache = get_pkg_info() cache.open() from softwarecenter.db.database import StoreDatabase xapian_base_path = "/var/cache/software-center" pathname = os.path.join(xapian_base_path, "xapian") db = StoreDatabase(pathname, cache) db.open() import softwarecenter.paths datadir = softwarecenter.paths.datadir from softwarecenter.ui.gtk3.utils import get_sc_icon_theme icons = get_sc_icon_theme(datadir) pkgs = ["apt", "software-center"] view = PackageNamesView("header", cache, pkgs, icons, 32, db) view.show() win = Gtk.Window() win.add(view) win.set_size_request(600, 400) win.show() win.connect('destroy', Gtk.main_quit) return win
def setUp(self): self.cache = FakedCache() self.db = StoreDatabase(cache=self.cache) self.lobby = lobbyview.LobbyView(cache=self.cache, db=self.db, icons=None, apps_filter=None) self.addCleanup(self.lobby.destroy)
def get_test_db(): from softwarecenter.db.database import StoreDatabase from softwarecenter.db.pkginfo import get_pkg_info import softwarecenter.paths cache = get_pkg_info() cache.open() db = StoreDatabase(softwarecenter.paths.XAPIAN_PATH, cache) db.open() return db
def setUp(self): cache = get_pkg_info() cache.open() xapian_base_path = XAPIAN_BASE_PATH pathname = os.path.join(xapian_base_path, "xapian") self.db = StoreDatabase(pathname, cache) self.db.open() self.catview = CategoriesParser(self.db) self.catview.db = self.db self.cats = self.catview.parse_applications_menu('/usr/share/app-install')
def _update_package_cache(self): """Update the cache with fresh data from PackageKit """ # we are not ready if the cache is invalid if not self._pkgs_cache: self._ready = False # we never want source packages pfilter = 1 << packagekit.FilterEnum.NOT_SOURCE pathname = os.path.join(XAPIAN_BASE_PATH, "xapian") db = StoreDatabase(pathname, self) db.open() docs = db.get_docs_from_query("") wanted_pkgs = list() for doc in docs: wanted_pkgs.append(db.get_pkgname(doc)) if len(wanted_pkgs) is 0: LOG.warning("no packages to process!") return # we never want source packages pfilter = 1 << packagekit.FilterEnum.NOT_SOURCE # Start async update of package-cache, as the data which was # loaded before (from on-disk cache) might not be fully up-to-date pkDaemonConf = glib.KeyFile() ret = pkDaemonConf.load_from_file("/etc/PackageKit/PackageKit.conf", glib.KeyFileFlags.NONE) # set maxItems to 100 by default maxItems = 100 if ret: try: maxItems = pkDaemonConf.get_integer("Daemon", "MaximumItemsToResolve") except Exception as e: LOG.error("Unable to read PackageKit daemon config: %s", str(e)) maxItems = 100 LOG.debug("maximum packages to resolve %i", maxItems) helper = self.PkResolveHelper(0) #steps = len(wanted_pkgs) + 0.5 // 100 for i in xrange(0, len(wanted_pkgs), maxItems): helper.steps = helper.steps + 1 for i in xrange(0, len(wanted_pkgs), maxItems): res = self.pkclient.resolve_async(pfilter, wanted_pkgs[i:i+maxItems], None, # cancellable lambda prog, t, u: None, # progress callback None, # progress user data, self._on_packages_resolve_ready, helper )
def setUp(self): self.datadir = softwarecenter.paths.datadir self.desktopdir = softwarecenter.paths.APP_INSTALL_PATH self.cache = FakedCache() self.db = StoreDatabase(cache=self.cache) self.lobby = catview_gtk.LobbyViewGtk(datadir=self.datadir, desktopdir=self.desktopdir, cache=self.cache, db=self.db, icons=None, apps_filter=None) self.addCleanup(self.lobby.destroy)
def __init__(self, parent=None): super(CategoriesModel, self).__init__() self._categories = [] roles = dict(enumerate(CategoriesModel.COLUMNS)) self.setRoleNames(roles) pathname = os.path.join(XAPIAN_BASE_PATH, "xapian") # FIXME: move this into app cache = get_pkg_info() db = StoreDatabase(pathname, cache) db.open() # /FIXME self.catparser = CategoriesParser(db) self._categories = self.catparser.parse_applications_menu()
def test_most_popular_applications_for_mimetype(self): pathname = os.path.join(REAL_DATA_DIR, "xapian") if not os.listdir(pathname): rebuild_database(pathname) db = StoreDatabase(pathname, self.cache) db.open() # all result = db.get_most_popular_applications_for_mimetype("text/html", only_uninstalled=False, num=5) self.assertEqual(len(result), 5) # only_uninstaleld result = db.get_most_popular_applications_for_mimetype("text/html", only_uninstalled=True, num=2) self.assertEqual(len(result), 2)
def test_whats_new(self): db = StoreDatabase("/var/cache/software-center/xapian", self.cache) db.open() query = xapian.Query("") enquire = xapian.Enquire(db.xapiandb) enquire.set_query(query) value_time = db._axi_values["catalogedtime"] enquire.set_sort_by_value(value_time, reverse=True) matches = enquire.get_mset(0, 20) last_time = 0 for m in matches: doc = m.document doc.get_value(value_time) >= last_time last_time = doc.get_value(value_time)
def _get_apps_for_category(self, category): query = get_query_for_category(self.db, category) if not query: LOG.warn("_get_apps_for_category: received invalid category") return [] pathname = os.path.join(XAPIAN_BASE_PATH, "xapian") db = StoreDatabase(pathname, self.cache) db.open() docs = db.get_docs_from_query(query) #from the db docs, return a list of pkgnames applist = [] for doc in docs: applist.append(db.get_pkgname(doc)) return applist
def test_non_axi_apps_cataloged_time(self): db = xapian.WritableDatabase("./data/test.db", xapian.DB_CREATE_OR_OVERWRITE) res = update_from_app_install_data(db, self.cache, datadir="./data/desktop") self.assertTrue(res) db = StoreDatabase("./data/test.db", self.cache) db.open(use_axi=True) axi_value_time = db._axi_values["catalogedtime"] sc_app = Application("Ubuntu Software Center Test", "software-center") sc_doc = db.get_xapian_document(sc_app.appname, sc_app.pkgname) sc_cataloged_time = sc_doc.get_value(axi_value_time) so_app = Application("Scintillant Orange", "scintillant-orange") so_doc = db.get_xapian_document(so_app.appname, so_app.pkgname) so_cataloged_time = so_doc.get_value(axi_value_time) # the test package Scintillant Orange should be cataloged at a # later time than axi package Ubuntu Software Center self.assertTrue(so_cataloged_time > sc_cataloged_time)
def __init__(self, parent=None): super(PkgListModel, self).__init__() self._docs = [] roles = dict(enumerate(PkgListModel.COLUMNS)) self.setRoleNames(roles) self._query = "" self._category = "" pathname = os.path.join(XAPIAN_BASE_PATH, "xapian") self.cache = get_pkg_info() self.db = StoreDatabase(pathname, self.cache) self.db.open(use_axi=False) self.backend = get_install_backend() self.backend.connect("transaction-progress-changed", self._on_backend_transaction_progress_changed) self.reviews = get_review_loader(self.cache) # FIXME: get this from a parent self._catparser = CategoriesParser(self.db) self._categories = self._catparser.parse_applications_menu( '/usr/share/app-install')
def test_package_states(self): db = xapian.WritableDatabase(TEST_DB, xapian.DB_CREATE_OR_OVERWRITE) res = update_from_app_install_data(db, self.cache, datadir=os.path.join( DATA_DIR, "desktop")) self.assertTrue(res) db = StoreDatabase(TEST_DB, self.cache) db.open(use_axi=False) # test PkgStates.INSTALLED # FIXME: this will only work if software-center is installed app = Application("Ubuntu Software Center Test", "software-center") appdetails = app.get_details(db) self.assertTrue(appdetails.pkg_state in (PkgStates.INSTALLED, PkgStates.UPGRADABLE)) # test PkgStates.UNINSTALLED # test PkgStates.UPGRADABLE # test PkgStates.REINSTALLABLE # test PkgStates.INSTALLING # test PkgStates.REMOVING # test PkgStates.UPGRADING # test PkgStates.NEEDS_SOURCE app = Application("Zynjacku Test", "zynjacku-fake") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.NEEDS_SOURCE) # test PkgStates.NEEDS_PURCHASE app = Application("The expensive gem", "expensive-gem") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.NEEDS_PURCHASE) self.assertEqual(appdetails.icon_url, "http://www.google.com/favicon.ico") self.assertEqual(appdetails.icon, "expensive-gem-icon-favicon") # test PkgStates.PURCHASED_BUT_REPO_MUST_BE_ENABLED # test PkgStates.UNKNOWN app = Application("Scintillant Orange", "scintillant-orange") appdetails = app.get_details(db) self.assertEqual(appdetails.pkg_state, PkgStates.NOT_FOUND) expected = ['use::converting', 'role::program', 'implemented-in::perl'] self.assertEqual(appdetails.tags, set(expected))
def test_reinstall_purchased_xapian(self): db = StoreDatabase("/var/cache/software-center/xapian", self.cache) db.open(use_axi=False) # now create purchased debs xapian index (in memory because # we store the repository passwords in here) old_db_len = len(db) query = add_from_purchased_but_needs_reinstall_data( self.available_to_me, db, self.cache) # ensure we have a new item (the available for reinstall one) self.assertEqual(len(db), old_db_len+1) # query enquire = xapian.Enquire(db.xapiandb) enquire.set_query(query) matches = enquire.get_mset(0, len(db)) self.assertEqual(len(matches), 1) for m in matches: doc = db.xapiandb.get_document(m.docid) self.assertEqual(doc.get_value(XapianValues.PKGNAME), "hellox") self.assertEqual(doc.get_value(XapianValues.ARCHIVE_SIGNING_KEY_ID), "1024R/0EB12F05") self.assertEqual(doc.get_value(XapianValues.ARCHIVE_DEB_LINE), "deb https://username:[email protected]/mvo/private-test/ubuntu maverick main #Personal access of username to private-test") break # only one match
def test_application_details(self): db = xapian.WritableDatabase("./data/test.db", xapian.DB_CREATE_OR_OVERWRITE) res = update_from_app_install_data(db, self.cache, datadir="./data/desktop") self.assertTrue(res) db = StoreDatabase("./data/test.db", self.cache) db.open(use_axi=False, use_agent=False) self.assertEqual(len(db), 5) # test details app = Application("Ubuntu Software Center Test", "software-center") details = app.get_details(db) self.assertNotEqual(details, None) self.assertEqual(details.component, "main") self.assertEqual(details.pkgname, "software-center") # get the first document for doc in db: if doc.get_data() == "Ubuntu Software Center Test": appdetails = AppDetails(db, doc=doc) break # test get_appname and get_pkgname self.assertEqual(db.get_appname(doc), "Ubuntu Software Center Test") self.assertEqual(db.get_pkgname(doc), "software-center") # test appdetails self.assertEqual(appdetails.name, "Ubuntu Software Center Test") self.assertEqual(appdetails.pkgname, "software-center") # FIXME: add a dekstop file with a real channel to test # and monkey-patch/modify the APP_INSTALL_CHANNELS_PATH self.assertEqual(appdetails.channelname, None) self.assertEqual(appdetails.channelfile, None) self.assertEqual(appdetails.component, "main") self.assertNotEqual(appdetails.pkg, None) # from the fake test/data/appdetails/var/lib/dpkg/status self.assertEqual(appdetails.pkg.is_installed, True) self.assertEqual(appdetails.pkg_state, PkgStates.INSTALLED) # FIXME: test description for unavailable pkg self.assertTrue( appdetails.description.startswith("Ubuntu Software Center lets you")) # FIXME: test appdetails.website self.assertEqual(appdetails.icon, "softwarecenter") # crude, crude self.assertTrue(len(appdetails.version) > 2) # FIXME: screenshots will only work on ubuntu self.assertTrue(re.match( "http://screenshots.ubuntu.com/screenshot-with-version/software-center/[\d.]+", appdetails.screenshot)) self.assertTrue(re.match( "http://screenshots.ubuntu.com/thumbnail-with-version/software-center/[\d.]+", appdetails.thumbnail)) # FIXME: add document that has a price self.assertEqual(appdetails.price, '') self.assertEqual(appdetails.license, "Open source") # test lazy history loading for installation date self.ensure_installation_date_and_lazy_history_loading(appdetails) # test apturl replacements # $kernel app = Application("", "linux-headers-$kernel", "channel=$distro-partner") self.assertEqual(app.pkgname, 'linux-headers-'+os.uname()[2]) # $distro details = app.get_details(db) from softwarecenter.distro import get_distro distro = get_distro().get_codename() self.assertEqual(app.request, 'channel=' + distro + '-partner')
def test_is_pkgname_known(self): db = StoreDatabase(cache=self.cache) db.open() self.assertTrue(db.is_pkgname_known("apt")) self.assertFalse(db.is_pkgname_known("i+am-not-a-pkg"))
class CardapioPlugin(CardapioPluginInterface): author = 'Cardapio team' name = _('Software Center') description = _('Search for new applications in the Software Center') url = '' help_text = '' version = '1.24' plugin_api_version = 1.40 search_delay_type = 'remote' # HACK: this should be 'local', but searching # the software center DB can be pretty slow, so we set # this to 'remote' as a stopgap measure. See: # https://bugs.launchpad.net/cardapio/+bug/642264 default_keyword = 'softwarecenter' category_name = _('Available Software') category_icon = 'softwarecenter' icon = 'softwarecenter' category_tooltip = _('Software available to install on your system') fallback_icon = 'applications-other' hide_from_sidebar = True def __init__(self, cardapio_proxy, category): ''' This method is called when the plugin is enabled. Nothing much to be done here except initialize variables and set loaded to True ''' self.c = cardapio_proxy self.loaded = False try: import xapian import sys import apt import os import gio import platform distro, ver, dummy = platform.linux_distribution() self.is_maverick_or_newer = (distro == ('Ubuntu') and ver in ['10.10', '11.04', '11.10', '12.04']) self.is_natty_or_newer = (distro == ('Ubuntu') and ver in ['11.04', '11.10', '12.04']) software_center_path = '/usr/share/software-center' if not os.path.exists(software_center_path): raise Exception('Could not find the software center path') sys.path.append(software_center_path) from softwarecenter.enums import XAPIAN_VALUE_POPCON, XAPIAN_VALUE_ICON, XAPIAN_VALUE_SUMMARY from softwarecenter.db.database import StoreDatabase from softwarecenter.view.appview import AppViewFilter if self.is_natty_or_newer: from softwarecenter.db.application import Application from softwarecenter.enums import PKG_STATE_UNINSTALLED except Exception, exception: self.c.write_to_log(self, 'Could not import certain modules', is_error = True) self.c.write_to_log(self, exception, is_error = True) return self.xapian = xapian self.apt = apt self.os = os self.gio = gio self.XAPIAN_VALUE_ICON = XAPIAN_VALUE_ICON self.XAPIAN_VALUE_SUMMARY = XAPIAN_VALUE_SUMMARY self.XAPIAN_VALUE_POPCON = XAPIAN_VALUE_POPCON self.StoreDatabase = StoreDatabase self.AppViewFilter = AppViewFilter if self.is_natty_or_newer: self.Application = Application self.PKG_STATE_UNINSTALLED = PKG_STATE_UNINSTALLED self.cache = self.apt.Cache() # this line is really slow! around 0.28s on my computer! db_path = '/var/cache/software-center/xapian' if not self.os.path.exists(db_path): self.c.write_to_log(self, 'Could not find the database path', is_error = True) return self.db = StoreDatabase(db_path, self.cache) self.db.open() self.apps_filter = AppViewFilter(self.db, self.cache) if self.is_maverick_or_newer: self.c.write_to_log(self, 'Detected Ubuntu 10.10 or higher') if self.is_natty_or_newer: self.apps_filter.set_not_installed_only(True) else: self.apps_filter.set_only_packages_without_applications(True) self.action = { 'name' : _('Open Software Center'), 'tooltip' : _('Search for more software in the Software Center'), 'icon name' : 'system-search', # using this icon because otherwise it looks strange... 'type' : 'callback', 'command' : self.open_softwarecenter_search, 'context menu' : None, } else: self.c.write_to_log(self, 'Detected Ubuntu older than 10.10') self.apps_filter.set_only_packages_without_applications(True) self.action = { 'name' : _('Open Software Center'), 'tooltip' : _('Search for more software in the Software Center'), 'icon name' : 'system-search', # using this icon because otherwise it looks strange... 'type' : 'raw', 'command' : 'software-center', 'context menu' : None, } self.context_menu_action_name = _('_Install %s') self.context_menu_action_tooltip = _('Install this package without opening the Software Center') self.default_tooltip_str = _('Show %s in the Software Center') self.summary_str = _('Description:') dpkg_path = '/var/lib/dpkg/lock' if self.os.path.exists(dpkg_path): self.package_monitor = self.gio.File(dpkg_path).monitor_file() self.package_monitor_handler = self.package_monitor.connect('changed', self.on_packages_changed) else: self.c.write_to_log(self, 'Path does not exist:' + dpkg_path, is_warning = True) self.c.write_to_log(self, 'Will not be able to monitor for package changes', is_warning = True) self.package_monitor = None self.loaded = True # set to true if everything goes well
def test_application_details(self): db = xapian.WritableDatabase(TEST_DB, xapian.DB_CREATE_OR_OVERWRITE) res = update_from_app_install_data(db, self.cache, datadir=os.path.join( DATA_DIR, "desktop")) self.assertTrue(res) db = StoreDatabase(TEST_DB, self.cache) db.open(use_axi=False, use_agent=False) self.assertEqual(len(db), 6) # test details app = Application("Ubuntu Software Center Test", "software-center") details = app.get_details(db) self.assertNotEqual(details, None) # mvo: disabled, we can reenable this once there is a static # apt rootdir and we do not rely on the test system to # have software-center from the main archive and not from # e.g. a custom repo like the ADT environment #self.assertEqual(details.component, "main") self.assertEqual(details.pkgname, "software-center") # get the first document for doc in db: if doc.get_data() == "Ubuntu Software Center Test": appdetails = AppDetails(db, doc=doc) break # test get_appname and get_pkgname self.assertEqual(db.get_appname(doc), "Ubuntu Software Center Test") self.assertEqual(db.get_pkgname(doc), "software-center") # test appdetails self.assertEqual(appdetails.name, "Ubuntu Software Center Test") self.assertEqual(appdetails.pkgname, "software-center") # FIXME: add a dekstop file with a real channel to test # and monkey-patch/modify the APP_INSTALL_CHANNELS_PATH self.assertEqual(appdetails.channelname, None) self.assertEqual(appdetails.channelfile, None) self.assertNotEqual(appdetails.pkg, None) # from the fake test/data/appdetails/var/lib/dpkg/status self.assertEqual(appdetails.pkg.is_installed, True) self.assertTrue(appdetails.pkg_state in (PkgStates.INSTALLED, PkgStates.UPGRADABLE)) # FIXME: test description for unavailable pkg self.assertTrue( appdetails.description.startswith( "Ubuntu Software Center lets you")) # FIXME: test appdetails.website self.assertEqual(appdetails.icon, "softwarecenter") # crude, crude self.assertTrue(len(appdetails.version) > 2) # FIXME: screenshots will only work on ubuntu self.assertTrue( re.match( "http://screenshots.ubuntu.com/screenshot-with-version/software-center/[\d.]+", appdetails.screenshot)) self.assertTrue( re.match( "http://screenshots.ubuntu.com/thumbnail-with-version/software-center/[\d.]+", appdetails.thumbnail)) # FIXME: add document that has a price self.assertEqual(appdetails.price, "Free") self.assertEqual(appdetails.raw_price, "") # mvo: disabled, we can reenable this once there is a static # apt rootdir and we do not rely on the test system to # have software-center from the main archive and not from # e.g. a custom repo like the ADT environment #self.assertEqual(appdetails.license, "Open source") # test lazy history loading for installation date self.ensure_installation_date_and_lazy_history_loading(appdetails) # test apturl replacements # $kernel app = Application("", "linux-headers-$kernel", "channel=$distro-partner") self.assertEqual(app.pkgname, 'linux-headers-' + os.uname()[2]) # $distro details = app.get_details(db) distro = softwarecenter.distro.get_distro().get_codename() self.assertEqual(app.request, 'channel=' + distro + '-partner')
def test_application(self): db = StoreDatabase("/var/cache/software-center/xapian", self.cache) # fail if AppDetails(db) without document= or application= # is run self.assertRaises(ValueError, AppDetails, db)
icons = get_sc_icon_theme(datadir) Gtk.Window.set_default_icon_name("softwarecenter") from softwarecenter.db.pkginfo import get_pkg_info cache = get_pkg_info() cache.open() # xapian import xapian from softwarecenter.paths import XAPIAN_BASE_PATH from softwarecenter.db.database import StoreDatabase xapian_base_path = XAPIAN_BASE_PATH pathname = os.path.join(xapian_base_path, "xapian") try: db = StoreDatabase(pathname, cache) db.open() except xapian.DatabaseOpeningError: # Couldn't use that folder as a database # This may be because we are in a bzr checkout and that # folder is empty. If the folder is empty, and we can find the # script that does population, populate a database in it. if os.path.isdir(pathname) and not os.listdir(pathname): from softwarecenter.db.update import rebuild_database logging.info("building local database") rebuild_database(pathname) db = StoreDatabase(pathname, cache) db.open() except xapian.DatabaseCorruptError as e: logging.exception("xapian open failed") dialogs.error(None, _("Sorry, can not open the software database"),
if __name__ == "__main__": def callback(app, reviews): print "app callback:" print app, reviews def stats_callback(stats): print "stats callback:" print stats # cache from softwarecenter.db.pkginfo import get_pkg_info cache = get_pkg_info() cache.open() db = StoreDatabase(XAPIAN_BASE_PATH + "/xapian", cache) db.open() # rnrclient loader app = Application("ACE", "unace") #app = Application("", "2vcard") from softwarecenter.backend.reviews.rnr import ( ReviewLoaderSpawningRNRClient ) loader = ReviewLoaderSpawningRNRClient(cache, db) print loader.refresh_review_stats(stats_callback) print loader.get_reviews(app, callback) print "\n\n" print "default loader, press ctrl-c for next loader"
def get_test_db(): cache = get_pkg_info() cache.open() db = StoreDatabase(softwarecenter.paths.XAPIAN_PATH, cache) db.open() return db