tests/testlaunch.py

   1 #!/usr/bin/env python2.3
   2 import sys, tempfile, os, shutil, imp
   3 from StringIO import StringIO
   4 import unittest
   5 import logging
   6
   7 foo_iface_uri = 'http://foo'
   8
   9 sys.path.insert(0, '..')
  10 from zeroinstall.injector import trust, basedir, autopolicy, namespaces, model, iface_cache, cli
  11
  12 class SilenceLogger(logging.Filter):
  13         def filter(self, record):
  14                 raise "Stop"
  15                 print "record", record
  16                 return 0
  17 silenceLogger = SilenceLogger()
  18
  19 class TestLaunch(unittest.TestCase):
  20         def setUp(self):
  21                 self.config_home = tempfile.mktemp()
  22                 self.cache_home = tempfile.mktemp()
  23                 os.environ['XDG_CONFIG_HOME'] = self.config_home
  24                 os.environ['XDG_CACHE_HOME'] = self.cache_home
  25                 os.environ['XDG_CACHE_DIRS'] = self.cache_home
  26                 reload(basedir)
  27                 iface_cache.iface_cache.__init__()
  28
  29                 os.mkdir(self.config_home, 0700)
  30                 os.mkdir(self.cache_home, 0700)
  31                 if os.environ.has_key('DISPLAY'):
  32                         del os.environ['DISPLAY']
  33
  34                 logging.getLogger().setLevel(logging.WARN)
  35
  36         def tearDown(self):
  37                 shutil.rmtree(self.config_home)
  38                 shutil.rmtree(self.cache_home)
  39
  40         def cache_iface(self, name, data):
  41                 cached_ifaces = basedir.save_cache_path('0install.net',
  42                                                         'interfaces')
  43
  44                 f = file(os.path.join(cached_ifaces, model.escape(name)), 'w')
  45                 f.write(data)
  46                 f.close()
  47
  48         def run_0launch(self, args):
  49                 sys.argv = ['0launch'] + args
  50                 old_stdout = sys.stdout
  51                 old_stderr = sys.stderr
  52                 try:
  53                         sys.stdout = StringIO()
  54                         sys.stderr = StringIO()
  55                         ex = None
  56                         try:
  57                                 imp.load_source('launch', '../0launch')
  58                                 print "Finished"
  59                         except SystemExit:
  60                                 pass
  61                         except AssertionError:
  62                                 raise
  63                         except Exception, ex:
  64                                 pass
  65                         out = sys.stdout.getvalue()
  66                         err = sys.stderr.getvalue()
  67                         if ex is not None:
  68                                 err += str(ex.__class__)
  69                 finally:
  70                         sys.stdout = old_stdout
  71                         sys.stderr = old_stderr
  72                 return (out, err)
  73
  74         def testHelp(self):
  75                 out, err = self.run_0launch([])
  76                 assert out.lower().startswith("usage:")
  77                 assert not err
  78
  79         def testList(self):
  80                 out, err = self.run_0launch(['--list'])
  81                 assert not err
  82                 self.assertEquals("", out)
  83                 cached_ifaces = os.path.join(self.cache_home,
  84                                         '0install.net', 'interfaces')
  85
  86                 os.makedirs(cached_ifaces)
  87                 file(os.path.join(cached_ifaces, 'file%3a%2f%2ffoo'), 'w').close()
  88
  89                 out, err = self.run_0launch(['--list'])
  90                 assert not err
  91                 self.assertEquals("file://foo\n", out)
  92
  93                 out, err = self.run_0launch(['--list', 'foo'])
  94                 assert not err
  95                 self.assertEquals("file://foo\n", out)
  96
  97                 out, err = self.run_0launch(['--list', 'bar'])
  98                 assert not err
  99                 self.assertEquals("", out)
 100
 101                 out, err = self.run_0launch(['--list', 'one', 'two'])
 102                 assert not err
 103                 assert out.lower().startswith("usage:")
 104
 105         def testVersion(self):
 106                 out, err = self.run_0launch(['--version'])
 107                 assert not err
 108                 assert out.startswith("0launch (zero-install)")
 109
 110         def testInvalid(self):
 111                 a = tempfile.NamedTemporaryFile()
 112                 out, err = self.run_0launch(['-q', a.name])
 113                 assert err
 114
 115         def testOK(self):
 116                 out, err = self.run_0launch(['--dry-run', 'http://foo'])
 117                 self.assertEquals("Would download 'http://foo'\n", out)
 118                 self.assertEquals("", err)
 119
 120         def testDisplay(self):
 121                 os.environ['DISPLAY'] = ':foo'
 122                 out, err = self.run_0launch(['--dry-run', 'http://foo'])
 123                 # Uses local copy of GUI
 124                 assert out.startswith("Would execute: ")
 125                 assert '0launch-gui' in out
 126                 self.assertEquals("", err)
 127
 128                 del os.environ['DISPLAY']
 129                 out, err = self.run_0launch(['--gui', '--dry-run'])
 130                 assert out.startswith("Would execute: ")
 131                 assert '0launch-gui' in out
 132                 self.assertEquals("", err)
 133
 134         def testRefreshDisplay(self):
 135                 os.environ['DISPLAY'] = ':foo'
 136                 out, err = self.run_0launch(['--dry-run', '--download-only',
 137                                      '--refresh', 'http://foo'])
 138                 assert out.startswith("Would execute: ")
 139                 assert '0launch-gui' in out
 140                 self.assertEquals("", err)
 141
 142         def testNeedDownload(self):
 143                 policy = autopolicy.AutoPolicy(foo_iface_uri)
 144                 policy.save_config()
 145                 os.environ['DISPLAY'] = ':foo'
 146                 out, err = self.run_0launch(['--download-only', '--dry-run', 'Foo.xml'])
 147                 self.assertEquals("", err)
 148                 self.assertEquals("Finished\n", out)
 149
 150         def testHello(self):
 151                 out, err = self.run_0launch(['--dry-run', 'Foo.xml'])
 152                 self.assertEquals("", err)
 153                 assert out.startswith("Would execute: ")
 154
 155                 out, err = self.run_0launch(['Foo.xml'])
 156                 # (Foo.xml tries to run a directory; plash gives a different error)
 157                 assert "Permission denied" in err or "Is a directory" in err
 158
 159         def testSource(self):
 160                 out, err = self.run_0launch(['--dry-run', '--source', 'Source.xml'])
 161                 self.assertEquals("", err)
 162                 assert 'Compiler.xml' in out
 163
 164         def testLogging(self):
 165                 log = logging.getLogger()
 166                 log.addFilter(silenceLogger)
 167
 168                 out, err = self.run_0launch(['-v', '--list', 'UNKNOWN'])
 169                 self.assertEquals(logging.INFO, log.level)
 170
 171                 out, err = self.run_0launch(['-vv', '--version'])
 172                 self.assertEquals(logging.DEBUG, log.level)
 173
 174                 log.removeFilter(silenceLogger)
 175                 log.setLevel(logging.WARN)
 176
 177         def testHelp(self):
 178                 out, err = self.run_0launch(['--help'])
 179                 self.assertEquals("", err)
 180                 assert 'options:' in out
 181
 182                 out, err = self.run_0launch([])
 183                 self.assertEquals("", err)
 184                 assert 'options:' in out
 185
 186         def testBadFD(self):
 187                 copy = os.dup(1)
 188                 try:
 189                         os.close(1)
 190                         try:
 191                                 cli.main(['--list', 'UNKNOWN'])
 192                                 assert False
 193                         except SystemExit:
 194                                 pass
 195                 finally:
 196                         os.dup2(copy, 1)
 197
 198 suite = unittest.makeSuite(TestLaunch)
 199 if __name__ == '__main__':
 200         sys.argv.append('-v')
 201         unittest.main()