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
