| 1 | import unittest
|
|---|
| 2 | import settestpath
|
|---|
| 3 |
|
|---|
| 4 | from yum import packages
|
|---|
| 5 | from rpmUtils import miscutils
|
|---|
| 6 |
|
|---|
| 7 | class InPrcoRangePackageTests(unittest.TestCase):
|
|---|
| 8 |
|
|---|
| 9 | def setUp(self):
|
|---|
| 10 | self.po = packages.RpmBase()
|
|---|
| 11 | self.po.prco['provides'].append(("seth", "EQ", (1, 2, 3)))
|
|---|
| 12 | self.po.prco['requires'].append(("foo", "GE", (4, 5, None)))
|
|---|
| 13 |
|
|---|
| 14 | def testRequiresEqPass(self):
|
|---|
| 15 | dep = ("foo", "EQ", (4, 5, 0))
|
|---|
| 16 | self.assertTrue(self.po.inPrcoRange('requires', dep))
|
|---|
| 17 |
|
|---|
| 18 | def testRequiresEqFailGt(self):
|
|---|
| 19 | dep = ("foo", "EQ", (4, 4, 0))
|
|---|
| 20 | self.assertFalse(self.po.inPrcoRange('requires', dep))
|
|---|
| 21 |
|
|---|
| 22 | def testProvidesGePass(self):
|
|---|
| 23 | dep = ("seth", "GE", (1, 0, 0))
|
|---|
| 24 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 25 |
|
|---|
| 26 | def testProvidesGePassWithEqual(self):
|
|---|
| 27 | dep = ("seth", "GE", (1, 2, 3))
|
|---|
| 28 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 29 |
|
|---|
| 30 | def testProvidesGeFailOnEpoch(self):
|
|---|
| 31 | dep = ("seth", "GE", (2, 0, 0))
|
|---|
| 32 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 33 |
|
|---|
| 34 | def testProvidesGeFailOnVersion(self):
|
|---|
| 35 | dep = ("seth", "GE", (1, 3, 0))
|
|---|
| 36 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 37 |
|
|---|
| 38 | def testProvidesGeFailOnRelease(self):
|
|---|
| 39 | dep = ("seth", "GE", (1, 2, 4))
|
|---|
| 40 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 41 |
|
|---|
| 42 | def testProvidesGtPass(self):
|
|---|
| 43 | dep = ("seth", "GT", (1, 0, 0))
|
|---|
| 44 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 45 |
|
|---|
| 46 | def testProvidesGtFail(self):
|
|---|
| 47 | dep = ("seth", "GT", (1, 2, 4))
|
|---|
| 48 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 49 |
|
|---|
| 50 | def testProvidesGtFailOnEqual(self):
|
|---|
| 51 | dep = ("seth", "GT", (1, 2, 3))
|
|---|
| 52 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 53 |
|
|---|
| 54 | def testProvidesEqPass(self):
|
|---|
| 55 | dep = ("seth", "EQ", (1, 2, 3))
|
|---|
| 56 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 57 |
|
|---|
| 58 | def testProvidesEqFailGt(self):
|
|---|
| 59 | dep = ("seth", "EQ", (1, 2, 0))
|
|---|
| 60 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 61 |
|
|---|
| 62 | def testProvidesEqFailLt(self):
|
|---|
| 63 | dep = ("seth", "EQ", (1, 2, 4))
|
|---|
| 64 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 65 |
|
|---|
| 66 | def testProvidesLePassEq(self):
|
|---|
| 67 | dep = ("seth", "LE", (1, 2, 3))
|
|---|
| 68 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 69 |
|
|---|
| 70 | def testProvidesLePassGt(self):
|
|---|
| 71 | dep = ("seth", "LE", (1, 5, 2))
|
|---|
| 72 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 73 |
|
|---|
| 74 | def testProvidesLeFail(self):
|
|---|
| 75 | dep = ("seth", "LE", (0, 2, 2))
|
|---|
| 76 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 77 |
|
|---|
| 78 | def testProvidesLtPass(self):
|
|---|
| 79 | dep = ("seth", "LT", (1, 2, 6))
|
|---|
| 80 | self.assertTrue(self.po.inPrcoRange('provides', dep))
|
|---|
| 81 |
|
|---|
| 82 | def testProvidesLtFailEq(self):
|
|---|
| 83 | dep = ("seth", "LT", (1, 2, 3))
|
|---|
| 84 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 85 |
|
|---|
| 86 | def testProvidesLtFailGt(self):
|
|---|
| 87 | dep = ("seth", "LT", (1, 0, 2))
|
|---|
| 88 | self.assertFalse(self.po.inPrcoRange('provides', dep))
|
|---|
| 89 |
|
|---|
| 90 |
|
|---|
| 91 | class PackageEvrTests(unittest.TestCase):
|
|---|
| 92 |
|
|---|
| 93 | def setUp(self):
|
|---|
| 94 | self.evr = packages.PackageEVR(0, 1, 2)
|
|---|
| 95 |
|
|---|
| 96 | def testLtPass(self):
|
|---|
| 97 | other_evr = packages.PackageEVR(0, 1, 5)
|
|---|
| 98 | self.assertTrue(self.evr < other_evr)
|
|---|
| 99 |
|
|---|
| 100 | def testLtFailEq(self):
|
|---|
| 101 | other_evr = packages.PackageEVR(0, 1, 2)
|
|---|
| 102 | self.assertFalse(self.evr < other_evr)
|
|---|
| 103 |
|
|---|
| 104 | def testLtFailGt(self):
|
|---|
| 105 | other_evr = packages.PackageEVR(0, 0, 2)
|
|---|
| 106 | self.assertFalse(self.evr < other_evr)
|
|---|
| 107 |
|
|---|
| 108 | def testLePassLt(self):
|
|---|
| 109 | other_evr = packages.PackageEVR(0, 1, 5)
|
|---|
| 110 | self.assertTrue(self.evr <= other_evr)
|
|---|
| 111 |
|
|---|
| 112 | def testLePassEq(self):
|
|---|
| 113 | other_evr = packages.PackageEVR(0, 1, 2)
|
|---|
| 114 | self.assertTrue(self.evr <= other_evr)
|
|---|
| 115 |
|
|---|
| 116 | def testLeFailGt(self):
|
|---|
| 117 | other_evr = packages.PackageEVR(0, 0, 2)
|
|---|
| 118 | self.assertFalse(self.evr <= other_evr)
|
|---|
| 119 |
|
|---|
| 120 | def testGtPass(self):
|
|---|
| 121 | other_evr = packages.PackageEVR(0, 1, 0)
|
|---|
| 122 | self.assertTrue(self.evr > other_evr)
|
|---|
| 123 |
|
|---|
| 124 | def testGtFailEq(self):
|
|---|
| 125 | other_evr = packages.PackageEVR(0, 1, 2)
|
|---|
| 126 | self.assertFalse(self.evr > other_evr)
|
|---|
| 127 |
|
|---|
| 128 | def testGtFailLt(self):
|
|---|
| 129 | other_evr = packages.PackageEVR(0, 2, 2)
|
|---|
| 130 | self.assertFalse(self.evr > other_evr)
|
|---|
| 131 |
|
|---|
| 132 | def testGePassGt(self):
|
|---|
| 133 | other_evr = packages.PackageEVR(0, 1, 0)
|
|---|
| 134 | self.assertTrue(self.evr >= other_evr)
|
|---|
| 135 |
|
|---|
| 136 | def testGePassEq(self):
|
|---|
| 137 | other_evr = packages.PackageEVR(0, 1, 2)
|
|---|
| 138 | self.assertTrue(self.evr >= other_evr)
|
|---|
| 139 |
|
|---|
| 140 | def testGeFailLt(self):
|
|---|
| 141 | other_evr = packages.PackageEVR(2, 1, 2)
|
|---|
| 142 | self.assertFalse(self.evr >= other_evr)
|
|---|
| 143 |
|
|---|
| 144 | def testEqPass(self):
|
|---|
| 145 | other_evr = packages.PackageEVR(0, 1, 2)
|
|---|
| 146 | self.assertTrue(self.evr == other_evr)
|
|---|
| 147 |
|
|---|
| 148 | def testEqFailGt(self):
|
|---|
| 149 | other_evr = packages.PackageEVR(0, 1, 0)
|
|---|
| 150 | self.assertFalse(self.evr == other_evr)
|
|---|
| 151 |
|
|---|
| 152 | def testEqFailLt(self):
|
|---|
| 153 | other_evr = packages.PackageEVR(0, 4, 2)
|
|---|
| 154 | self.assertFalse(self.evr == other_evr)
|
|---|
| 155 |
|
|---|
| 156 |
|
|---|
| 157 | class StubPkg(object):
|
|---|
| 158 |
|
|---|
| 159 | def __init__(self, n, a, e, v, r):
|
|---|
| 160 | self.pkgtup = (n, a, e, v, r)
|
|---|
| 161 |
|
|---|
| 162 |
|
|---|
| 163 | class BuildPackageDictRefTests(unittest.TestCase):
|
|---|
| 164 |
|
|---|
| 165 | def testNoPkg(self):
|
|---|
| 166 | pkgs = []
|
|---|
| 167 | self.assertEquals({}, packages.buildPkgRefDict(pkgs))
|
|---|
| 168 |
|
|---|
| 169 | def testOnePkg(self):
|
|---|
| 170 | pkg = StubPkg("yum", "noarch", 0, "3.1.1", 2)
|
|---|
| 171 | pkgs = [pkg]
|
|---|
| 172 | pkg_dict = packages.buildPkgRefDict(pkgs)
|
|---|
| 173 |
|
|---|
| 174 | self.assertEquals(7, len(pkg_dict))
|
|---|
| 175 |
|
|---|
| 176 | unseen_keys = ['yum', 'yum.noarch', 'yum-3.1.1-2.noarch', 'yum-3.1.1',
|
|---|
| 177 | 'yum-3.1.1-2', '0:yum-3.1.1-2.noarch', 'yum-0:3.1.1-2.noarch']
|
|---|
| 178 | for key in pkg_dict.keys():
|
|---|
| 179 | self.assertTrue(key in unseen_keys)
|
|---|
| 180 | unseen_keys.remove(key)
|
|---|
| 181 | self.assertEquals(1, len(pkg_dict[key]))
|
|---|
| 182 | self.assertEquals(pkg, pkg_dict[key][0])
|
|---|
| 183 |
|
|---|
| 184 | self.assertEquals(0, len(unseen_keys))
|
|---|
| 185 |
|
|---|
| 186 | def _perms(evr): # Magic comp. sci. stuff ... oooh
|
|---|
| 187 | e, v, r = evr
|
|---|
| 188 | for num in range(8):
|
|---|
| 189 | perm = []
|
|---|
| 190 | if num & 1:
|
|---|
| 191 | perm.append(e)
|
|---|
| 192 | else:
|
|---|
| 193 | perm.append(None)
|
|---|
| 194 | if num & 2:
|
|---|
| 195 | perm.append(v)
|
|---|
| 196 | else:
|
|---|
| 197 | perm.append(None)
|
|---|
| 198 | if num & 4:
|
|---|
| 199 | perm.append(r)
|
|---|
| 200 | else:
|
|---|
| 201 | perm.append(None)
|
|---|
| 202 | yield tuple(perm)
|
|---|
| 203 |
|
|---|
| 204 | class RangeCompareTests(unittest.TestCase):
|
|---|
| 205 |
|
|---|
| 206 | def testRangeCompare(self):
|
|---|
| 207 | def tst(requires, provides, result):
|
|---|
| 208 | print requires, provides
|
|---|
| 209 | self.assertEquals(miscutils.rangeCompare(requires, provides),result)
|
|---|
| 210 | def tst_lege_prov(requires, provides, result):
|
|---|
| 211 | if not result or provides[1] != 'EQ':
|
|---|
| 212 | return
|
|---|
| 213 | for flag in ('GE', 'LE'): # EQ is a subset of either LE or GE
|
|---|
| 214 | nprovides = (provides[0], flag, provides[2])
|
|---|
| 215 | tst(requires, nprovides, result)
|
|---|
| 216 | def tst_lege_reqs(requires, provides, result):
|
|---|
| 217 | tst_lege_prov(requires, provides, result)
|
|---|
| 218 | if not result or requires[1] != 'EQ':
|
|---|
| 219 | return
|
|---|
| 220 | for flag in ('GE', 'LE'): # EQ is a subset of either LE or GE
|
|---|
| 221 | nrequires = (requires[0], flag, requires[2])
|
|---|
| 222 | tst(nrequires, provides, result)
|
|---|
| 223 | tst_lege_prov(nrequires, provides, result)
|
|---|
| 224 | def tst_none_reqs(requires, provides, result):
|
|---|
| 225 | if (not result or requires[1] or provides[1] != 'EQ' or
|
|---|
| 226 | requires[2] != (None, None, None)):
|
|---|
| 227 | return
|
|---|
| 228 | tst_lege_prov(requires, provides, result)
|
|---|
| 229 | # Doesn't matter about versions
|
|---|
| 230 | for flag in ('GE', 'EQ', 'LE'):
|
|---|
| 231 | nrequires = (requires[0], flag, requires[2])
|
|---|
| 232 | tst(nrequires, provides, result)
|
|---|
| 233 | tst_lege_prov(nrequires, provides, result)
|
|---|
| 234 | def tst_none_expand(requires, provides, result, *args):
|
|---|
| 235 | if requires[2] != (None, None, None):
|
|---|
| 236 | return
|
|---|
| 237 | # Expand parts of the version, replacing with data from provides.
|
|---|
| 238 | # Eg. (None, None, None) and ('1', '2', '3') becomes:
|
|---|
| 239 | # (None, None, None)
|
|---|
| 240 | # ('1', None, None)
|
|---|
| 241 | # (None, '2', None)
|
|---|
| 242 | # (None, None, '3')
|
|---|
| 243 | # ('1', '2', None)
|
|---|
| 244 | # ...
|
|---|
| 245 | # ('1', '2', '3')
|
|---|
| 246 |
|
|---|
| 247 | for evr in _perms(provides[2]):
|
|---|
| 248 | nrequires = (requires[0], requires[1], evr)
|
|---|
| 249 | for func in args:
|
|---|
| 250 | func(nrequires, provides, result)
|
|---|
| 251 |
|
|---|
| 252 | for requires, provides, result in (
|
|---|
| 253 | (('foo', 'EQ', ('0', '1.4.4', '0')), ('foo', 'EQ', ('0', '1.4.4', '0')), 1),
|
|---|
| 254 | (('foo', 'EQ', ('0', '1.4.4', '0')), ('foo', 'EQ', (None, '1.4.4', '0')), 1),
|
|---|
| 255 | (('foo', 'EQ', ('0', '1.4.4', '0')), ('foo', 'EQ', ('0', '1.4.4', None)), 1),
|
|---|
| 256 | (('foo', 'EQ', ('0', '1.4.4', None)), ('foo', 'EQ', ('0', '1.4.4', '8')), 1),
|
|---|
| 257 | (('foo', 'LT', ('0', '1.5.4', None)), ('foo', 'EQ', ('0', '1.4.4', '7')), 1),
|
|---|
| 258 | (('foo', 'GE', ('0', '1.4.4', '7.1')), ('foo', 'EQ', ('0', '1.4.4', '7')), 0),
|
|---|
| 259 | (('foo', 'EQ', ('0', '1.4', None)), ('foo', 'EQ', ('0', '1.4.4', '7')), 0),
|
|---|
| 260 | (('foo', 'GT', ('1', '1.4.4', None)), ('foo', 'EQ', ('3', '1.2.4', '7')), 1),
|
|---|
| 261 | (('foo', None, (None, None, None)), ('foo', 'EQ', ('3', '1.2.4', '7')), 1),
|
|---|
| 262 | (('fuu', None, (None, None, None)), ('foo', 'EQ', ('3', '1.2.4', '7')), 0),
|
|---|
| 263 | (('foo', None, (None, None, None)), ('foo', 'GT', ('3', '1.2.4', '7')), 1),
|
|---|
| 264 |
|
|---|
| 265 | (('foo', 'EQ', (None, None, None)), ('foo', 'GT', ('3', '1.2.4', '7')), 0),
|
|---|
| 266 | (('foo', 'LT', (None, None, None)), ('foo', 'GT', ('3', '1.2.4', '7')), 0),
|
|---|
| 267 | (('foo', 'LE', (None, None, None)), ('foo', 'GT', ('3', '1.2.4', '7')), 0),
|
|---|
| 268 | (('foo', 'GE', (None, None, None)), ('foo', 'GT', ('3', '1.2.4', '7')), 1),
|
|---|
| 269 | (('foo', 'GT', (None, None, None)), ('foo', 'GT', ('3', '1.2.4', '7')), 1),
|
|---|
| 270 |
|
|---|
| 271 | (('foo', 'EQ', (None, None, None)), ('foo', 'LT', ('3', '1.2.4', '7')), 0),
|
|---|
| 272 | (('foo', 'LT', (None, None, None)), ('foo', 'LT', ('3', '1.2.4', '7')), 1),
|
|---|
| 273 | (('foo', 'LE', (None, None, None)), ('foo', 'LT', ('3', '1.2.4', '7')), 1),
|
|---|
| 274 | (('foo', 'GE', (None, None, None)), ('foo', 'LT', ('3', '1.2.4', '7')), 0),
|
|---|
| 275 | (('foo', 'GT', (None, None, None)), ('foo', 'LT', ('3', '1.2.4', '7')), 0),
|
|---|
| 276 | ):
|
|---|
| 277 |
|
|---|
| 278 | tst(requires, provides, result)
|
|---|
| 279 |
|
|---|
| 280 | tst_lege_reqs(requires, provides, result)
|
|---|
| 281 | tst_none_expand(requires, provides, result,
|
|---|
| 282 | tst, tst_lege_reqs, tst_none_reqs)
|
|---|
