tests/testmodel.py

   1 #!/usr/bin/env python2.3
   2 import sys, tempfile, os, shutil
   3 import unittest
   4 from StringIO import StringIO
   5
   6 sys.path.insert(0, '..')
   7 from zeroinstall.injector import model, qdom
   8
   9 class TestModel(unittest.TestCase):
  10         def testLevels(self):
  11                 assert model.network_offline in model.network_levels
  12                 assert model.network_minimal in model.network_levels
  13                 assert model.network_full in model.network_levels
  14
  15         def testStabilities(self):
  16                 assert 'insecure' in model.stability_levels
  17                 assert 'buggy' in model.stability_levels
  18                 assert 'developer' in model.stability_levels
  19                 assert 'testing' in model.stability_levels
  20                 assert 'stable' in model.stability_levels
  21                 assert 'preferred' in model.stability_levels
  22                 str(model.insecure)
  23
  24         def testEscape(self):
  25                 self.assertEquals("", model.escape(""))
  26                 self.assertEquals("hello", model.escape("hello"))
  27                 self.assertEquals("%20", model.escape(" "))
  28                 self.assertEquals("file%3a%2f%2ffoo%7ebar",
  29                                 model.escape("file://foo~bar"))
  30                 self.assertEquals("file%3a%2f%2ffoo%25bar",
  31                                 model.escape("file://foo%bar"))
  32
  33         def testUnescape(self):
  34                 self.assertEquals("", model.unescape(""))
  35                 self.assertEquals("hello", model.unescape("hello"))
  36                 self.assertEquals(" ", model.unescape("%20"))
  37                 self.assertEquals("file://foo~bar",
  38                                 model.unescape("file%3a%2f%2ffoo%7ebar"))
  39                 self.assertEquals("file://foo%bar",
  40                                 model.unescape("file%3a%2f%2ffoo%25bar"))
  41
  42         def testBadInterface(self):
  43                 try:
  44                         model.Interface('foo')
  45                         assert 0
  46                 except model.SafeException:
  47                         pass
  48
  49         def testInterface(self):
  50                 i = model.Interface('http://foo')
  51                 self.assertEquals('(foo)', i.get_name())
  52                 repr(i)
  53
  54         def testMetadata(self):
  55                 i = model.Interface('http://foo')
  56                 e = qdom.parse(StringIO('<ns:b xmlns:ns="a" foo="bar"/>'))
  57                 i.metadata = [e]
  58                 assert i.get_metadata('a', 'b') == [e]
  59                 assert i.get_metadata('b', 'b') == []
  60                 assert i.get_metadata('a', 'a') == []
  61                 assert e.getAttribute('foo') == 'bar'
  62
  63         def testStabPolicy(self):
  64                 i = model.Interface('http://foo')
  65                 self.assertEquals(None, i.stability_policy)
  66                 i.set_stability_policy(model.buggy)
  67                 self.assertEquals(model.buggy, i.stability_policy)
  68
  69         def testGetImpl(self):
  70                 i = model.Interface('http://foo')
  71                 a = i.get_impl('foo')
  72                 b = i.get_impl('bar')
  73                 c = i.get_impl('foo')
  74                 assert a and b and c
  75                 assert a is c
  76                 assert a is not b
  77                 assert isinstance(a, model.Implementation)
  78
  79         def testImpl(self):
  80                 i = model.Interface('http://foo')
  81                 a = model.Implementation(i, 'foo')
  82                 assert a.id == 'foo'
  83                 assert a.size == a.version == a.user_stability == None
  84                 assert a.arch == a.upstream_stability == None
  85                 assert a.dependencies == {}
  86                 assert a.download_sources == []
  87                 assert a.get_stability() is model.testing
  88                 a.upstream_stability = model.stable
  89                 assert a.get_stability() is model.stable
  90                 a.user_stability = model.buggy
  91                 assert a.get_stability() is model.buggy
  92                 a.version = [1,2,3]
  93                 self.assertEquals('1.2.3', a.get_version())
  94                 assert str(a) == 'foo'
  95
  96                 b = model.Implementation(i, 'foo')
  97                 b.version = [1,2,1]
  98                 assert b > a
  99
 100         def testDownloadSource(self):
 101                 i = model.Interface('http://foo')
 102                 a = model.Implementation(i, 'foo')
 103                 a.add_download_source('ftp://foo', 1024, None)
 104                 a.add_download_source('ftp://foo.tgz', 1025, 'foo')
 105                 assert a.download_sources[0].url == 'ftp://foo'
 106                 assert a.download_sources[0].size == 1024
 107                 assert a.download_sources[0].extract == None
 108                 assert a.interface is i
 109
 110         def testEnvBind(self):
 111                 a = model.EnvironmentBinding('PYTHONPATH', 'path')
 112                 assert a.name == 'PYTHONPATH'
 113                 assert a.insert == 'path'
 114                 str(a)
 115
 116         def testDep(self):
 117                 b = model.Dependency('http://foo')
 118                 assert not b.restrictions
 119                 assert not b.bindings
 120                 str(b)
 121
 122         def testFeed(self):
 123                 f = model.Feed('http://feed', arch = None, user_override = False)
 124                 assert f.uri == 'http://feed'
 125                 assert f.os == None
 126                 assert f.machine == None
 127                 assert f.arch == None
 128                 assert f.user_override == False
 129
 130                 f = model.Feed('http://feed', arch = 'Linux-*', user_override = True)
 131                 assert f.uri == 'http://feed'
 132                 assert f.os == 'Linux'
 133                 assert f.machine == None
 134                 assert f.arch == 'Linux-*'
 135                 assert f.user_override == True
 136
 137                 f = model.Feed('http://feed', arch = '*-i386', user_override = True)
 138                 assert f.uri == 'http://feed'
 139                 assert f.os == None
 140                 assert f.machine == 'i386'
 141                 assert f.arch == '*-i386'
 142                 assert f.user_override == True
 143                 assert str(f).startswith('<Feed from')
 144
 145                 try:
 146                         f = model.Feed('http://feed', arch = 'i386', user_override = True)
 147                         assert false
 148                 except model.SafeException, ex:
 149                         assert 'Malformed arch' in str(ex)
 150
 151         def testCanonical(self):
 152                 self.assertEquals('http://foo',
 153                                 model.canonical_iface_uri('http://foo'))
 154                 try:
 155                         model.canonical_iface_uri('bad-name')
 156                         assert false
 157                 except model.SafeException, ex:
 158                         assert 'Bad interface name' in str(ex)
 159
 160 suite = unittest.makeSuite(TestModel)
 161 if __name__ == '__main__':
 162         sys.argv.append('-v')
 163         unittest.main()