tests/testendtoend.py

   1 #!/usr/bin/env python2.4
   2 import os
   3 import subprocess
   4 import sys
   5 import unittest
   6
   7 sys.path.insert(0, '..')
   8
   9 from basetest import BaseTest
  10 from basetest import write_file
  11 from zeroinstall.injector import autopolicy
  12 from zeroinstall.injector import run
  13 from zeroinstall.injector.iface_cache import iface_cache
  14 from zeroinstall.zerostore import manifest
  15
  16
  17 # Based on code in 0publish/archive.py
  18 def manifest_for_dir(dir):
  19         algorithm = manifest.get_algorithm("sha1new")
  20         digest = algorithm.new_digest()
  21         for line in algorithm.generate_manifest(dir):
  22                 digest.update(line + '\n')
  23         return algorithm.getID(digest)
  24
  25
  26 def command_for_policy(policy):
  27         root_impl = policy.get_implementation(
  28                 iface_cache.get_interface(policy.root))
  29         return os.path.join(run._get_implementation_path(root_impl.id),
  30                             root_impl.main)
  31
  32
  33 class FileTreeWriter(object):
  34
  35         def __init__(self, files):
  36                 self._files = files
  37
  38         def write_tree(self, dest_path):
  39                 for filename, data in self._files:
  40                         pathname = os.path.join(dest_path, filename)
  41                         if not os.path.exists(os.path.dirname(pathname)):
  42                                 os.makedirs(os.path.dirname(pathname))
  43                         write_file(pathname, data)
  44                         # Making everything executable is simpler.
  45                         os.chmod(pathname, 0777)
  46
  47
  48 class TestEndToEnd(BaseTest):
  49         def _make_archive(self, tree):
  50                 tar_file = os.path.join(self.make_temp_dir(), "archive.tar.gz")
  51                 temp_dir = self.make_temp_dir()
  52                 tree.write_tree(temp_dir)
  53                 subprocess.check_call(["tar", "-czf", tar_file, "-C", temp_dir, "."])
  54                 return """
  55       <implementation id="%s" version="1">
  56         <archive href="%s" size="%i"/>
  57       </implementation>
  58       """ % (manifest_for_dir(temp_dir), tar_file, os.path.getsize(tar_file))
  59
  60         def test_module_with_no_dependencies(self):
  61                 tree = FileTreeWriter([("hello-test", """\
  62 #!/bin/sh
  63 echo Hello world!
  64 """)])
  65                 feed_file = self.make_temp_file("""
  66 <interface xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
  67   <name>Test</name>
  68   <summary>Placeholder</summary>
  69   <group main="hello-test">
  70     %s
  71   </group>
  72 </interface>
  73 """ % self._make_archive(tree))
  74                 policy = autopolicy.AutoPolicy(
  75                         feed_file, download_only=True, dry_run=False)
  76                 policy.download_and_execute([])
  77                 cmd_path = command_for_policy(policy)
  78                 proc = subprocess.Popen([cmd_path], stdout=subprocess.PIPE)
  79                 stdout, stderr = proc.communicate()
  80                 self.assertEquals(proc.wait(), 0)
  81                 self.assertEquals(stdout, "Hello world!\n")
  82
  83         def test_module_with_dependency(self):
  84                 library_tree = FileTreeWriter([("share/useful", "useful-contents\n")])
  85                 main_tree = FileTreeWriter([("bin/hello-test", """\
  86 #!/bin/sh
  87 echo Got:
  88 cat $LIBFOO/share/useful
  89 """)])
  90                 library_feed = self.make_temp_file("""\
  91 <?xml version="1.0" ?>
  92 <interface xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
  93   <name>Test</name>
  94   <summary>Placeholder</summary>
  95   <group>
  96     %s
  97   </group>
  98 </interface>
  99 """ % self._make_archive(library_tree))
 100                 main_feed = self.make_temp_file("""
 101 <interface xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
 102   <name>Test</name>
 103   <summary>Placeholder</summary>
 104   <group main="bin/hello-test">
 105     %s
 106     <requires interface="%s">
 107       <environment name="LIBFOO" insert="."/>
 108     </requires>
 109   </group>
 110 </interface>
 111 """ % (self._make_archive(main_tree), library_feed))
 112                 policy = autopolicy.AutoPolicy(
 113                         main_feed, download_only=True, dry_run=False)
 114                 policy.download_and_execute([])
 115                 env = {}
 116                 run.add_env_bindings(env, policy)
 117                 self.assertEquals(env.keys(), ["LIBFOO"])
 118                 cmd_path = command_for_policy(policy)
 119                 proc = subprocess.Popen([cmd_path], stdout=subprocess.PIPE, env=env)
 120                 stdout, stderr = proc.communicate()
 121                 self.assertEquals(proc.wait(), 0)
 122                 self.assertEquals(stdout, "Got:\nuseful-contents\n")
 123
 124         def test_self_environment_binding(self):
 125                 tree = FileTreeWriter([("share/useful", "useful-contents\n"),
 126                                        ("bin/hello-test", """\
 127 #!/bin/sh
 128 echo Got:
 129 cat $MY_DATA_DIR/share/useful
 130 """)])
 131                 feed_file = self.make_temp_file("""
 132 <interface xmlns="http://zero-install.sourceforge.net/2004/injector/interface">
 133   <name>Test</name>
 134   <summary>Placeholder</summary>
 135   <group main="bin/hello-test">
 136     %s
 137     <environment name="MY_DATA_DIR" insert="."/>
 138   </group>
 139 </interface>
 140 """ % (self._make_archive(tree)))
 141                 policy = autopolicy.AutoPolicy(
 142                         feed_file, download_only=True, dry_run=False)
 143                 policy.download_and_execute([])
 144                 env = {}
 145                 run.add_env_bindings(env, policy)
 146                 self.assertEquals(env.keys(), ["MY_DATA_DIR"])
 147                 cmd_path = command_for_policy(policy)
 148                 proc = subprocess.Popen([cmd_path], stdout=subprocess.PIPE, env=env)
 149                 stdout, stderr = proc.communicate()
 150                 self.assertEquals(proc.wait(), 0)
 151                 self.assertEquals(stdout, "Got:\nuseful-contents\n")
 152
 153
 154 suite = unittest.makeSuite(TestEndToEnd)
 155 if __name__ == '__main__':
 156         sys.argv.append('-v')
 157         unittest.main()