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