tests/testdistro.py

   1 #!/usr/bin/env python
   2 from basetest import BaseTest, empty_feed, DummyPackageKit
   3 import sys, os, tempfile
   4 from StringIO import StringIO
   5 import unittest
   6
   7 sys.path.insert(0, '..')
   8 from zeroinstall.injector import distro, model, qdom, iface_cache, handler
   9
  10 def parse_impls(impls):
  11         xml = """<?xml version="1.0" ?>
  12                  <interface xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
  13                    <name>Foo</name>
  14                    <summary>Foo</summary>
  15                    <description>Foo</description>
  16                    %s
  17                 </interface>""" % impls
  18         element = qdom.parse(StringIO(xml))
  19         return model.ZeroInstallFeed(element, "myfeed.xml")
  20
  21 class TestDistro(BaseTest):
  22         def setUp(self):
  23                 BaseTest.setUp(self)
  24                 self.feed = model.ZeroInstallFeed(empty_feed, local_path = '/empty.xml')
  25
  26         def tearDown(self):
  27                 BaseTest.tearDown(self)
  28
  29         def testCache(self):
  30                 src = tempfile.NamedTemporaryFile()
  31                 try:
  32                         cache = distro.Cache('test-cache', src.name, 1)
  33                         self.assertEquals(None, cache.get("foo"))
  34                         cache.put("foo", "1")
  35                         self.assertEquals("1", cache.get("foo"))
  36                         cache.put("foo", "2")
  37                         self.assertEquals("2", cache.get("foo"))
  38
  39                         # new cache...
  40                         cache = distro.Cache('test-cache', src.name, 1)
  41                         self.assertEquals("2", cache.get("foo"))
  42
  43                         src.write("hi")
  44                         src.flush()
  45
  46                         self.assertEquals(None, cache.get("foo"))
  47                         cache.put("foo", "3")
  48
  49                         # new cache... (format change)
  50                         cache = distro.Cache('test-cache', src.name, 2)
  51                         self.assertEquals(None, cache.get("foo"))
  52
  53                 finally:
  54                         src.close()
  55
  56         def make_factory(self, distro):
  57                 def factory(id, only_if_missing = False, installed = True):
  58                         assert not only_if_missing
  59                         impl = model.DistributionImplementation(self.feed, id, distro)
  60                         assert id not in self.feed.implementations
  61                         self.feed.implementations[id] = impl
  62                         impl.installed = installed
  63                         return impl
  64                 return factory
  65
  66         def testDefault(self):
  67                 host = distro.Distribution()
  68
  69                 factory = self.make_factory(host)
  70                 host.get_package_info('gimp', factory)
  71                 self.assertEquals(self.feed.implementations, {})
  72
  73         def testDebian(self):
  74                 dpkgdir = os.path.join(os.path.dirname(__file__), 'dpkg')
  75                 host = distro.DebianDistribution(
  76                                 os.path.join(dpkgdir, 'status'),
  77                                 os.path.join(dpkgdir, 'pkgcache.bin'))
  78                 host._packagekit = DummyPackageKit()
  79
  80                 factory = self.make_factory(host)
  81                 host.get_package_info('gimp', factory)
  82                 self.assertEquals({}, self.feed.implementations)
  83
  84                 # Initially, we only get information about the installed version...
  85                 host.get_package_info('python-bittorrent', factory)
  86                 self.assertEquals(1, len(self.feed.implementations))
  87
  88                 # Tell distro to fetch information about candidates...
  89                 master_feed = parse_impls("""<package-implementation package='python-bittorrent'/>""")
  90                 h = handler.Handler()
  91                 candidates = host.fetch_candidates(master_feed)
  92                 if candidates:
  93                         h.wait_for_blocker(candidates)
  94                 # Now we see the uninstalled package
  95                 self.feed = model.ZeroInstallFeed(empty_feed, local_path = '/empty.xml')
  96                 host.get_package_info('python-bittorrent', factory)
  97                 self.assertEquals(2, len(self.feed.implementations))
  98
  99                 self.assertEquals(2, len(self.feed.implementations))
 100                 bittorrent_installed = self.feed.implementations['package:deb:python-bittorrent:3.4.2-10:*']
 101                 bittorrent_uninstalled = self.feed.implementations['package:deb:python-bittorrent:3.4.2-11.1:*']
 102                 self.assertEquals('3.4.2-10', bittorrent_installed.get_version())
 103                 self.assertTrue(bittorrent_installed.installed)
 104                 self.assertFalse(bittorrent_uninstalled.installed)
 105                 self.assertEquals(None, bittorrent_installed.machine)
 106
 107                 self.feed = model.ZeroInstallFeed(empty_feed, local_path = '/empty.xml')
 108                 host.get_package_info('libxcomposite-dev', factory)
 109                 self.assertEquals(1, len(self.feed.implementations))
 110                 libxcomposite = self.feed.implementations['package:deb:libxcomposite-dev:0.3.1-1:i386']
 111                 self.assertEquals('0.3.1-1', libxcomposite.get_version())
 112                 self.assertEquals('i386', libxcomposite.machine)
 113
 114         def testRPM(self):
 115                 rpmdir = os.path.join(os.path.dirname(__file__), 'rpm')
 116                 os.environ['PATH'] = rpmdir + ':' + self.old_path
 117                 rpm = distro.RPMDistribution(os.path.join(rpmdir, 'status'))
 118
 119                 self.assertEquals(2, len(rpm.versions))
 120
 121                 factory = self.make_factory(rpm)
 122                 rpm.get_package_info('yast2-update', factory)
 123                 self.assertEquals(1, len(self.feed.implementations))
 124                 yast = self.feed.implementations['package:rpm:yast2-update:2.15.23-21:i586']
 125                 self.assertEquals('2.15.23-21', yast.get_version())
 126                 self.assertEquals('*-i586', yast.arch)
 127
 128                 icache = iface_cache.IfaceCache(distro = rpm)
 129
 130                 feed = parse_impls("""
 131                                 <package-implementation distributions="Debian" package="yast2-mail"/>
 132                                 <package-implementation distributions="RPM" package="yast2-update"/>
 133                                 """)
 134                 icache._feeds[feed.url] = feed
 135                 distro_feed_url = feed.get_distro_feed()
 136                 impls = icache.get_feed(distro_feed_url).implementations
 137                 self.assertEquals("distribution:myfeed.xml", distro_feed_url)
 138                 assert len(impls) == 1, impls
 139                 impl, = impls
 140                 assert impl == 'package:rpm:yast2-update:2.15.23-21:i586'
 141
 142                 feed = parse_impls("""
 143                                 <package-implementation distributions="RPM" package="yast2-mail"/>
 144                                 <package-implementation distributions="RPM" package="yast2-update"/>
 145                                 """)
 146                 icache._feeds[feed.url] = feed
 147                 del icache._feeds['distribution:' + feed.url]
 148                 impls = icache.get_feed(feed.get_distro_feed()).implementations
 149                 assert len(impls) == 2, impls
 150
 151                 feed = parse_impls("""
 152                                 <package-implementation distributions="" package="yast2-mail"/>
 153                                 <package-implementation package="yast2-update"/>
 154                                 """)
 155                 icache._feeds[feed.url] = feed
 156                 del icache._feeds['distribution:' + feed.url]
 157                 impls = icache.get_feed(feed.get_distro_feed()).implementations
 158                 assert len(impls) == 2, impls
 159
 160         def testSlack(self):
 161                 slackdir = os.path.join(os.path.dirname(__file__), 'slack')
 162                 slack = distro.SlackDistribution(os.path.join(slackdir, 'packages'))
 163
 164                 factory = self.make_factory(slack)
 165                 slack.get_package_info('gimp', factory)
 166                 self.assertEquals({}, self.feed.implementations)
 167
 168                 slack.get_package_info('infozip', factory)
 169                 self.assertEquals(1, len(self.feed.implementations))
 170                 zip = self.feed.implementations['package:slack:infozip:5.52-2:i486']
 171                 self.assertEquals('5.52-2', zip.get_version())
 172                 self.assertEquals('i486', zip.machine)
 173
 174         def testGentoo(self):
 175                 pkgdir = os.path.join(os.path.dirname(__file__), 'gentoo')
 176                 ebuilds = distro.GentooDistribution(pkgdir)
 177
 178                 factory = self.make_factory(ebuilds)
 179                 ebuilds.get_package_info('media-gfx/gimp', factory)
 180                 self.assertEquals({}, self.feed.implementations)
 181
 182                 ebuilds.get_package_info('sys-apps/portage', factory)
 183                 self.assertEquals(1, len(self.feed.implementations))
 184                 impl = self.feed.implementations['package:gentoo:sys-apps/portage:2.1.7.16:x86_64']
 185                 self.assertEquals('2.1.7.16', impl.get_version())
 186                 self.assertEquals('x86_64', impl.machine)
 187
 188                 ebuilds.get_package_info('sys-kernel/gentoo-sources', factory)
 189                 self.assertEquals(3, len(self.feed.implementations))
 190                 impl = self.feed.implementations['package:gentoo:sys-kernel/gentoo-sources:2.6.30-4:i686']
 191                 self.assertEquals('2.6.30-4', impl.get_version())
 192                 self.assertEquals('i686', impl.machine)
 193                 impl = self.feed.implementations['package:gentoo:sys-kernel/gentoo-sources:2.6.32:x86_64']
 194                 self.assertEquals('2.6.32', impl.get_version())
 195                 self.assertEquals('x86_64', impl.machine)
 196
 197                 ebuilds.get_package_info('app-emulation/emul-linux-x86-baselibs', factory)
 198                 self.assertEquals(4, len(self.feed.implementations))
 199                 impl = self.feed.implementations['package:gentoo:app-emulation/emul-linux-x86-baselibs:20100220:i386']
 200                 self.assertEquals('20100220', impl.get_version())
 201                 self.assertEquals('i386', impl.machine)
 202
 203         def testPorts(self):
 204                 pkgdir = os.path.join(os.path.dirname(__file__), 'ports')
 205                 ports = distro.PortsDistribution(pkgdir)
 206
 207                 factory = self.make_factory(ports)
 208                 ports.get_package_info('zeroinstall-injector', factory)
 209                 self.assertEquals(1, len(self.feed.implementations))
 210                 impl = self.feed.implementations['package:ports:zeroinstall-injector:0.41-2:' + distro.host_machine]
 211                 self.assertEquals('0.41-2', impl.get_version())
 212                 self.assertEquals(distro.host_machine, impl.machine)
 213
 214         def testCleanVersion(self):
 215                 self.assertEquals('0.3.1-1', distro.try_cleanup_distro_version('1:0.3.1-1'))
 216                 self.assertEquals('0.3.1-1', distro.try_cleanup_distro_version('0.3.1-1ubuntu0'))
 217                 self.assertEquals('0.3-post1-rc2', distro.try_cleanup_distro_version('0.3-post1-rc2'))
 218                 self.assertEquals('0.3.1-2', distro.try_cleanup_distro_version('0.3.1-r2-r3'))
 219
 220 if __name__ == '__main__':
 221         unittest.main()