| 1 | from testbase import *
|
|---|
| 2 | import simpleobsoletestests
|
|---|
| 3 |
|
|---|
| 4 | # Obsolete for conflict
|
|---|
| 5 | class ComplicatedTests(OperationsTests):
|
|---|
| 6 |
|
|---|
| 7 | @staticmethod
|
|---|
| 8 | def buildPkgs(pkgs, *args):
|
|---|
| 9 | simpleobsoletestests.SimpleObsoletesTests.buildPkgs(pkgs)
|
|---|
| 10 | # conflicts
|
|---|
| 11 | pkgs.conflicts = FakePackage('super-zippy', '0.3', '1', '0', 'i386')
|
|---|
| 12 | pkgs.conflicts.addConflicts('zsh', 'EQ', ('0', '1', '1'))
|
|---|
| 13 |
|
|---|
| 14 | def testObsoleteForConflict(self):
|
|---|
| 15 | p = self.pkgs
|
|---|
| 16 | res, msg = self.runOperation(['install', 'super-zippy'], [p.installed_i386], [p.obsoletes_i386, p.obsoletes_x86_64, p.conflicts])
|
|---|
| 17 | if new_behavior:
|
|---|
| 18 | self.assert_(res=='ok', msg)
|
|---|
| 19 | self.assertResult((p.obsoletes_i386, p.conflicts))
|
|---|
| 20 |
|
|---|
| 21 | class CombinedUpdateObsoletesTest(OperationsTests):
|
|---|
| 22 |
|
|---|
| 23 | @staticmethod
|
|---|
| 24 | def buildPkgs(pkgs, *args):
|
|---|
| 25 | pkgs.k_1 = FakePackage('k', '3.5')
|
|---|
| 26 | pkgs.kdevel_1 = FakePackage('k-devel', '3.5')
|
|---|
| 27 | pkgs.kdevel_1.addRequires('k')
|
|---|
| 28 | pkgs.klibs_1_i386 = FakePackage('klibs', '3.5', arch='i386')
|
|---|
| 29 | pkgs.klibs_1_x86_64 = FakePackage('klibs', '3.5', arch='x86_64')
|
|---|
| 30 | pkgs.k_2 = FakePackage('k', '3.5', '2')
|
|---|
| 31 | pkgs.kdevel_2 = FakePackage('k-devel', '3.5', '2')
|
|---|
| 32 | pkgs.kdevel_2.addRequires('k')
|
|---|
| 33 | pkgs.klibs_2_i386 = FakePackage('klibs', '3.5', '2', arch='i386')
|
|---|
| 34 | pkgs.klibs_2_i386.addObsoletes('klibs', 'LT', (None, '3.5', '2'))
|
|---|
| 35 | pkgs.klibs_2_i386.addObsoletes('k', 'LT', (None, '3.5', '2'))
|
|---|
| 36 | pkgs.klibs_2_x86_64 = FakePackage('klibs', '3.5', '2', arch='x86_64')
|
|---|
| 37 | pkgs.klibs_2_x86_64.addObsoletes('klibs', 'LT', (None, '3.5', '2'))
|
|---|
| 38 | pkgs.klibs_2_x86_64.addObsoletes('k', 'LT', (None, '3.5', '2'))
|
|---|
| 39 |
|
|---|
| 40 | def testSelfObsolete(self):
|
|---|
| 41 | p = self.pkgs
|
|---|
| 42 | res, msg = self.runOperation(['update'], [p.klibs_1_x86_64], [p.klibs_2_i386, p.klibs_2_x86_64])
|
|---|
| 43 | self.assert_(res=='ok', msg)
|
|---|
| 44 | self.assertResult((p.klibs_2_x86_64,))
|
|---|
| 45 |
|
|---|
| 46 | def testPackageSplitWithObsoleteAndRequiresForUpdate(self):
|
|---|
| 47 | p = self.pkgs
|
|---|
| 48 | res, msg = self.runOperation(['update'], [p.k_1, p.kdevel_1, p.klibs_1_x86_64],
|
|---|
| 49 | [p.k_2, p.kdevel_2, p.klibs_2_x86_64])
|
|---|
| 50 | self.assert_(res=='ok', msg)
|
|---|
| 51 | self.assertResult((p.k_2, p.kdevel_2, p.klibs_2_x86_64,))
|
|---|
| 52 |
|
|---|
| 53 |
|
|---|
| 54 |
|
|---|
| 55 | class ComplicatedObsoletesTests(OperationsTests):
|
|---|
| 56 |
|
|---|
| 57 | @staticmethod
|
|---|
| 58 | def buildPkgs(pkgs, *args):
|
|---|
| 59 | pkgs.installed = FakePackage('foo', '1.4', '1')
|
|---|
| 60 | pkgs.obsoletecircle = FakePackage('foo', '1.4', '1')
|
|---|
| 61 | pkgs.obsoletecircle.addObsoletes('baz')
|
|---|
| 62 | pkgs.obsoletes = FakePackage('bar', '1.2', '1')
|
|---|
| 63 | pkgs.obsoletes.addObsoletes('foo')
|
|---|
| 64 | pkgs.obsoletes2 = FakePackage('baz', '1.8', '1')
|
|---|
| 65 | pkgs.obsoletes2.addObsoletes('bar')
|
|---|
| 66 |
|
|---|
| 67 | def testObsoleteChain(self):
|
|---|
| 68 | p = self.pkgs
|
|---|
| 69 | res, msg = self.runOperation(['update'], [p.installed], [p.obsoletes, p.obsoletes2])
|
|---|
| 70 | self.assert_(res=='ok', msg)
|
|---|
| 71 | if True or new_behavior:
|
|---|
| 72 | self.assertResult((p.obsoletes2,))
|
|---|
| 73 | else:
|
|---|
| 74 | self.assertResult((p.obsoletes,))
|
|---|
| 75 | def testObsoleteChainNext(self):
|
|---|
| 76 | p = self.pkgs
|
|---|
| 77 | res, msg = self.runOperation(['update'], [p.obsoletes], [p.obsoletes2])
|
|---|
| 78 | self.assert_(res=='ok', msg)
|
|---|
| 79 | self.assertResult((p.obsoletes2,))
|
|---|
| 80 |
|
|---|
| 81 | def testObsoleteCircle(self):
|
|---|
| 82 | p = self.pkgs
|
|---|
| 83 | res, msg = self.runOperation(['update'], [p.obsoletecircle], [p.obsoletes, p.obsoletes2])
|
|---|
| 84 | self.assert_(res=='ok', msg)
|
|---|
| 85 | if new_behavior:
|
|---|
| 86 | self.assertResult((p.obsoletecircle,))
|
|---|
| 87 | else:
|
|---|
| 88 | self.assertResult((p.obsoletes2,))
|
|---|
| 89 | def testObsoleteCircleNext(self):
|
|---|
| 90 | p = self.pkgs
|
|---|
| 91 | res, msg = self.runOperation(['update'], [p.obsoletes], [p.obsoletecircle, p.obsoletes, p.obsoletes2])
|
|---|
| 92 | self.assert_(res=='ok', msg)
|
|---|
| 93 | if new_behavior:
|
|---|
| 94 | self.assertResult((p.obsoletes,))
|
|---|
| 95 | else:
|
|---|
| 96 | self.assertResult((p.obsoletes2,))
|
|---|
| 97 | def testObsoleteCircleNextNext(self):
|
|---|
| 98 | p = self.pkgs
|
|---|
| 99 | res, msg = self.runOperation(['update'], [p.obsoletes2], [p.obsoletecircle, p.obsoletes, p.obsoletes2])
|
|---|
| 100 | self.assert_(res=='ok', msg)
|
|---|
| 101 | if new_behavior:
|
|---|
| 102 | self.assertResult((p.obsoletes2,))
|
|---|
| 103 | else:
|
|---|
| 104 | self.assertResult((p.obsoletecircle,))
|
|---|
| 105 | def testObsoleteCircleNextNextNext(self):
|
|---|
| 106 | p = self.pkgs
|
|---|
| 107 | res, msg = self.runOperation(['update'], [p.obsoletecircle], [p.obsoletes, p.obsoletes2])
|
|---|
| 108 | self.assert_(res=='ok', msg)
|
|---|
| 109 | if new_behavior:
|
|---|
| 110 | self.assertResult((p.obsoletecircle,))
|
|---|
| 111 | else:
|
|---|
| 112 | self.assertResult((p.obsoletes2,))
|
|---|
| 113 | # continue endlessly
|
|---|
| 114 |
|
|---|
| 115 | class KernelTests(OperationsTests):
|
|---|
| 116 |
|
|---|
| 117 | @staticmethod
|
|---|
| 118 | def buildPkgs(pkgs, *args):
|
|---|
| 119 | pkgs.inst = []
|
|---|
| 120 | pkgs.inst.append(FakePackage('kernel', '2.6.23.8', '63',arch='i686'))
|
|---|
| 121 | pkgs.inst.append(FakePackage('kernel', '2.6.23.1', '49',arch='i686'))
|
|---|
| 122 | pkgs.avail = []
|
|---|
| 123 | pkgs.avail.append(FakePackage('kernel', '2.6.23.8', '63',arch='i686'))
|
|---|
| 124 | pkgs.avail.append(FakePackage('kernel', '2.6.23.8', '63',arch='i586'))
|
|---|
| 125 | pkgs.avail.append(FakePackage('kernel', '2.6.23.1', '49',arch='i686'))
|
|---|
| 126 | pkgs.avail.append(FakePackage('kernel', '2.6.23.1', '49',arch='i586'))
|
|---|
| 127 | pkgs.avail.append(FakePackage('kernel', '2.6.23.1', '42',arch='i686'))
|
|---|
| 128 | pkgs.avail.append(FakePackage('kernel', '2.6.23.1', '42',arch='i586'))
|
|---|
| 129 |
|
|---|
| 130 | def testKernelInstall1(self):
|
|---|
| 131 | p = self.pkgs
|
|---|
| 132 | res, msg = self.runOperation(['install','kernel'], p.inst, p.avail)
|
|---|
| 133 | self.assertResult(p.inst)
|
|---|
| 134 |
|
|---|
| 135 | def testKernelInstall2(self):
|
|---|
| 136 | p = self.pkgs
|
|---|
| 137 | res, msg = self.runOperation(['install','kernel-2.6.23.1-42'], p.inst, p.avail)
|
|---|
| 138 | self.assertResult(p.inst + [ p.avail[4] ] )
|
|---|
| 139 |
|
|---|
| 140 | def testKernelInstall3(self):
|
|---|
| 141 | p = self.pkgs
|
|---|
| 142 | res, msg = self.runOperation(['install','kernel-2.6.23.8'], p.inst, p.avail)
|
|---|
| 143 | self.assertResult(p.inst)
|
|---|
| 144 |
|
|---|
| 145 | class MultiLibTests(OperationsTests):
|
|---|
| 146 |
|
|---|
| 147 | @staticmethod
|
|---|
| 148 | def buildPkgs(pkgs, *args):
|
|---|
| 149 | pkgs.inst = []
|
|---|
| 150 | pkgs.i_foo_1_12_x = FakePackage('foo', '1', '12',arch='x86_64')
|
|---|
| 151 | pkgs.i_wbar_1_12_i = FakePackage('wbar', '1', '12', arch='i586')
|
|---|
| 152 | pkgs.inst.append(pkgs.i_foo_1_12_x)
|
|---|
| 153 | pkgs.inst.append(pkgs.i_wbar_1_12_i)
|
|---|
| 154 |
|
|---|
| 155 | pkgs.avail = []
|
|---|
| 156 | pkgs.a_foo_0_2_x = FakePackage('foo', '0', '2', arch='x86_64')
|
|---|
| 157 | pkgs.a_foo_0_2_i = FakePackage('foo', '0', '2', arch='i686')
|
|---|
| 158 | pkgs.a_foo_1_12_x = FakePackage('foo', '1', '12', arch='x86_64')
|
|---|
| 159 | pkgs.a_foo_1_12_i = FakePackage('foo', '1', '12', arch='i686')
|
|---|
| 160 | pkgs.a_foo_2_22_x = FakePackage('foo', '2', '22', arch='x86_64')
|
|---|
| 161 | pkgs.a_foo_2_22_i = FakePackage('foo', '2', '22', arch='i686')
|
|---|
| 162 | pkgs.a_bar_1_12_x = FakePackage('bar', '1', '12', arch='x86_64')
|
|---|
| 163 | pkgs.a_bar_1_12_i = FakePackage('bar', '1', '12', arch='i686')
|
|---|
| 164 | pkgs.a_bar_2_22_x = FakePackage('bar', '2', '22', arch='x86_64')
|
|---|
| 165 | pkgs.a_bar_2_22_i = FakePackage('bar', '2', '22', arch='i686')
|
|---|
| 166 |
|
|---|
| 167 | # ibar is .i?86 older
|
|---|
| 168 | pkgs.a_ibar_2_22_x = FakePackage('ibar', '2', '22', arch='x86_64')
|
|---|
| 169 | pkgs.a_ibar_1_12_i = FakePackage('ibar', '1', '12', arch='i686')
|
|---|
| 170 |
|
|---|
| 171 | # xbar is .x86_64 older
|
|---|
| 172 | pkgs.a_xbar_1_12_x = FakePackage('xbar', '1', '12', arch='x86_64')
|
|---|
| 173 | pkgs.a_xbar_2_22_i = FakePackage('xbar', '2', '22', arch='i686')
|
|---|
| 174 |
|
|---|
| 175 | # wbar is arch changing update/downgrade
|
|---|
| 176 | pkgs.a_wbar_0_2_i = FakePackage('wbar', '0', '2', arch='i386')
|
|---|
| 177 | pkgs.a_wbar_2_22_i = FakePackage('wbar', '2', '22', arch='i686')
|
|---|
| 178 |
|
|---|
| 179 | for i in ('a_foo_0_2', 'a_foo_1_12', 'a_foo_2_22',
|
|---|
| 180 | 'a_bar_1_12', 'a_bar_2_22'):
|
|---|
| 181 | pkgs.avail.append(getattr(pkgs, i + '_x'))
|
|---|
| 182 | pkgs.avail.append(getattr(pkgs, i + '_i'))
|
|---|
| 183 | pkgs.avail.append(pkgs.a_ibar_2_22_x)
|
|---|
| 184 | pkgs.avail.append(pkgs.a_ibar_1_12_i)
|
|---|
| 185 | pkgs.avail.append(pkgs.a_xbar_1_12_x)
|
|---|
| 186 | pkgs.avail.append(pkgs.a_xbar_2_22_i)
|
|---|
| 187 | pkgs.avail.append(pkgs.a_wbar_0_2_i)
|
|---|
| 188 | pkgs.avail.append(pkgs.a_wbar_2_22_i)
|
|---|
| 189 |
|
|---|
| 190 | def testBestInstall1(self):
|
|---|
| 191 | p = self.pkgs
|
|---|
| 192 | ninst = p.inst[:]
|
|---|
| 193 | ninst.append(p.a_bar_2_22_x)
|
|---|
| 194 | res, msg = self.runOperation(['install', 'bar'], p.inst, p.avail)
|
|---|
| 195 | self.assertResult(ninst)
|
|---|
| 196 |
|
|---|
| 197 | def testBestInstall2(self):
|
|---|
| 198 | p = self.pkgs
|
|---|
| 199 | ninst = p.inst[:]
|
|---|
| 200 | ninst.append(p.a_bar_1_12_x)
|
|---|
| 201 | res, msg = self.runOperation(['install', 'bar-1'], p.inst, p.avail)
|
|---|
| 202 | self.assertResult(ninst)
|
|---|
| 203 |
|
|---|
| 204 | def testAllInstall1(self):
|
|---|
| 205 | p = self.pkgs
|
|---|
| 206 | ninst = p.inst[:]
|
|---|
| 207 | ninst.append(p.a_bar_2_22_x)
|
|---|
| 208 | ninst.append(p.a_bar_2_22_i)
|
|---|
| 209 | res, msg = self.runOperation(['install', 'bar'], p.inst, p.avail,
|
|---|
| 210 | {'multilib_policy' : 'all'})
|
|---|
| 211 | self.assertResult(ninst)
|
|---|
| 212 |
|
|---|
| 213 | def testAllInstall2(self):
|
|---|
| 214 | p = self.pkgs
|
|---|
| 215 | ninst = p.inst[:]
|
|---|
| 216 | ninst.append(p.a_bar_1_12_x)
|
|---|
| 217 | ninst.append(p.a_bar_1_12_i)
|
|---|
| 218 | res, msg = self.runOperation(['install', 'bar-1'], p.inst, p.avail,
|
|---|
| 219 | {'multilib_policy' : 'all'})
|
|---|
| 220 | self.assertResult(ninst)
|
|---|
| 221 |
|
|---|
| 222 | def testAllInstall3(self):
|
|---|
| 223 | p = self.pkgs
|
|---|
| 224 | ninst = p.inst[:]
|
|---|
| 225 | ninst.append(p.a_ibar_2_22_x)
|
|---|
| 226 | res, msg = self.runOperation(['install', 'ibar'], p.inst, p.avail,
|
|---|
| 227 | {'multilib_policy' : 'all'})
|
|---|
| 228 | self.assertResult(ninst)
|
|---|
| 229 |
|
|---|
| 230 | def testAllInstall4(self):
|
|---|
| 231 | p = self.pkgs
|
|---|
| 232 | ninst = p.inst[:]
|
|---|
| 233 | ninst.append(p.a_xbar_2_22_i)
|
|---|
| 234 | res, msg = self.runOperation(['install', 'xbar'], p.inst, p.avail,
|
|---|
| 235 | {'multilib_policy' : 'all'})
|
|---|
| 236 | self.assertResult(ninst)
|
|---|
| 237 |
|
|---|
| 238 | def testDowngrade1(self):
|
|---|
| 239 | p = self.pkgs
|
|---|
| 240 | ninst = [p.i_foo_1_12_x, p.a_wbar_0_2_i]
|
|---|
| 241 | res, msg = self.runOperation(['downgrade', 'wbar'], p.inst, p.avail)
|
|---|
| 242 | self.assertResult(ninst)
|
|---|
| 243 |
|
|---|
| 244 | def testDowngrade2(self):
|
|---|
| 245 | p = self.pkgs
|
|---|
| 246 | oinst = [p.i_foo_1_12_x, p.a_wbar_2_22_i]
|
|---|
| 247 | ninst = [p.i_foo_1_12_x, p.i_wbar_1_12_i]
|
|---|
| 248 | p.avail.append(p.i_wbar_1_12_i)
|
|---|
| 249 | res, msg = self.runOperation(['downgrade', 'wbar'], oinst, p.avail)
|
|---|
| 250 | self.assertResult(ninst)
|
|---|
| 251 |
|
|---|
| 252 | def testDowngrade3(self):
|
|---|
| 253 | p = self.pkgs
|
|---|
| 254 | oinst = [p.i_foo_1_12_x, p.a_wbar_2_22_i]
|
|---|
| 255 | ninst = [p.i_foo_1_12_x, p.a_wbar_0_2_i]
|
|---|
| 256 | res, msg = self.runOperation(['downgrade', 'wbar'], oinst, p.avail)
|
|---|
| 257 | self.assertResult(ninst)
|
|---|
| 258 |
|
|---|
| 259 | def testDowngrade4(self):
|
|---|
| 260 | p = self.pkgs
|
|---|
| 261 | oinst = p.inst[:] + [p.a_ibar_2_22_x]
|
|---|
| 262 | p.a_ibar_1_12_i.arch = 'noarch'
|
|---|
| 263 | ninst = p.inst[:] + [p.a_ibar_1_12_i]
|
|---|
| 264 | res, msg = self.runOperation(['downgrade', 'ibar'], oinst, p.avail)
|
|---|
| 265 | self.assertResult(ninst)
|
|---|
| 266 |
|
|---|
| 267 | def testDowngrade5(self):
|
|---|
| 268 | p = self.pkgs
|
|---|
| 269 | ninst = p.inst[:] + [p.a_xbar_1_12_x]
|
|---|
| 270 | p.a_xbar_2_22_i.arch = 'noarch'
|
|---|
| 271 | oinst = p.inst[:] + [p.a_xbar_2_22_i]
|
|---|
| 272 | res, msg = self.runOperation(['downgrade', 'xbar'], oinst, p.avail)
|
|---|
| 273 | self.assertResult(ninst)
|
|---|
