tests/testpackagekit.py

   1 #!/usr/bin/env python
   2 from basetest import BaseTest
   3 import sys
   4 import unittest
   5
   6 sys.path.insert(0, '..')
   7 from zeroinstall.injector import packagekit, handler, model
   8 from zeroinstall.support import tasks
   9
  10 h = handler.Handler()
  11
  12 import dbus
  13
  14 class PackageKit05:
  15         x = 0
  16
  17         def GetTid(self):
  18                 self.x += 1
  19                 return "/tid/%d" % self.x
  20
  21         class Tid:
  22                 def __init__(self):
  23                         self.signals = {}
  24
  25                 def connect_to_signal(self, signal, cb):
  26                         self.signals[signal] = cb
  27
  28                 def get_dbus_method(self, method):
  29                         if hasattr(self, method):
  30                                 return getattr(self, method)
  31                         raise dbus.exceptions.DBusException('org.freedesktop.DBus.Error.UnknownMethod')
  32
  33                 def SetLocale(self, locale):
  34                         pass
  35
  36         class Tid1(Tid):
  37                 def Resolve(self, query, package_names):
  38                         @tasks.async
  39                         def later():
  40                                 yield
  41                                 result = "success"
  42                                 for package_name in package_names:
  43                                         if package_name == 'gimp':
  44                                                 info = {}
  45                                                 self.signals['Package'](info, "gimp;2.6.8-2ubuntu1.1;amd64;Ubuntu", "summary")
  46                                         else:
  47                                                 self.signals['Error']("package-not-found", "Package name %s could not be resolved" % package_name)
  48                                                 result = "failed"
  49                                 yield
  50                                 self.signals['Finished'](result, 100)
  51                         later()
  52
  53         class Tid2(Tid):
  54                 def GetDetails(self, package_ids):
  55                         @tasks.async
  56                         def later():
  57                                 yield
  58                                 for package_id in package_ids:
  59                                         assert package_id == "gimp;2.6.8-2ubuntu1.1;amd64;Ubuntu"
  60                                         self.signals['Details'](package_id, "GPL", "Graphics", "detail", "http://foo", 100)
  61
  62                                 yield
  63                                 self.signals['Finished']("success", 100)
  64                         later()
  65
  66 class TestPackageKit(BaseTest):
  67         def setUp(self):
  68                 BaseTest.setUp(self)
  69
  70         def tearDown(self):
  71                 sys.meta_path = []
  72                 BaseTest.tearDown(self)
  73
  74         def find_module(self, fullname, path=None):
  75                 if fullname.startswith('dbus'):
  76                         raise ImportError("No (dummy) D-BUS")
  77                 else:
  78                         return None
  79
  80         def testNoDBUS(self):
  81                 import dbus
  82                 old_dbus = dbus
  83                 try:
  84                         sys.meta_path = [self]
  85                         del sys.modules['dbus']
  86
  87                         reload(packagekit)
  88
  89                         pk = packagekit.PackageKit()
  90                         assert pk.available == False
  91
  92                         factory = Exception("not called")
  93                         pk.get_candidates('gimp', factory, 'package:null')
  94                 finally:
  95                         self.meta_path = []
  96                         sys.modules['dbus'] = old_dbus
  97
  98         def testNoPackageKit(self):
  99                 reload(packagekit)
 100                 pk = packagekit.PackageKit()
 101                 assert not pk.available
 102
 103                 factory = Exception("not called")
 104                 pk.get_candidates('gimp', factory, 'package:null')
 105
 106         def testPackageKit05(self):
 107                 #import logging; logging.getLogger().setLevel(logging.DEBUG)
 108
 109                 dbus.system_services['org.freedesktop.PackageKit'] = {
 110                         '/org/freedesktop/PackageKit': PackageKit05(),
 111                         '/tid/1': PackageKit05.Tid1(),
 112                         '/tid/2': PackageKit05.Tid2(),
 113                 }
 114                 reload(packagekit)
 115                 pk = packagekit.PackageKit()
 116                 assert pk.available
 117
 118                 factory = Exception("not called")
 119                 pk.get_candidates('gimp', factory, 'package:test')
 120
 121                 blocker = pk.fetch_candidates(["gimp"])
 122                 h.wait_for_blocker(blocker)
 123                 tasks.check(blocker)
 124
 125                 impls = {}
 126                 def factory(impl_id, only_if_missing, installed):
 127                         assert impl_id.startswith('package:')
 128                         assert only_if_missing is True
 129                         assert installed is False
 130
 131                         feed = None
 132
 133                         impl = model.DistributionImplementation(feed, impl_id, self)
 134                         impl.installed = installed
 135                         impls[impl_id] = impl
 136                         return impl
 137
 138                 pk.get_candidates('gimp', factory, 'package:test')
 139                 self.assertEquals(["package:test:gimp:2.6.8-2"], impls.keys())
 140
 141 if __name__ == '__main__':
 142         unittest.main()