buildbot/test/test_buildreq.py

   1 # -*- test-case-name: buildbot.test.test_buildreq -*-
   2
   3 from twisted.trial import unittest
   4
   5 from buildbot import buildset, interfaces, sourcestamp
   6 from buildbot.process import base
   7 from buildbot.status import builder
   8 from buildbot.changes.changes import Change
   9
  10 class Request(unittest.TestCase):
  11     def testMerge(self):
  12         R = base.BuildRequest
  13         S = sourcestamp.SourceStamp
  14         b1 =  R("why", S("branch1", None, None, None))
  15         b1r1 = R("why2", S("branch1", "rev1", None, None))
  16         b1r1a = R("why not", S("branch1", "rev1", None, None))
  17         b1r2 = R("why3", S("branch1", "rev2", None, None))
  18         b2r2 = R("why4", S("branch2", "rev2", None, None))
  19         b1r1p1 = R("why5", S("branch1", "rev1", (3, "diff"), None))
  20         c1 = Change("alice", [], "changed stuff", branch="branch1")
  21         c2 = Change("alice", [], "changed stuff", branch="branch1")
  22         c3 = Change("alice", [], "changed stuff", branch="branch1")
  23         c4 = Change("alice", [], "changed stuff", branch="branch1")
  24         c5 = Change("alice", [], "changed stuff", branch="branch1")
  25         c6 = Change("alice", [], "changed stuff", branch="branch1")
  26         b1c1 = R("changes", S("branch1", None, None, [c1,c2,c3]))
  27         b1c2 = R("changes", S("branch1", None, None, [c4,c5,c6]))
  28
  29         self.failUnless(b1.canBeMergedWith(b1))
  30         self.failIf(b1.canBeMergedWith(b1r1))
  31         self.failIf(b1.canBeMergedWith(b2r2))
  32         self.failIf(b1.canBeMergedWith(b1r1p1))
  33         self.failIf(b1.canBeMergedWith(b1c1))
  34
  35         self.failIf(b1r1.canBeMergedWith(b1))
  36         self.failUnless(b1r1.canBeMergedWith(b1r1))
  37         self.failIf(b1r1.canBeMergedWith(b2r2))
  38         self.failIf(b1r1.canBeMergedWith(b1r1p1))
  39         self.failIf(b1r1.canBeMergedWith(b1c1))
  40
  41         self.failIf(b1r2.canBeMergedWith(b1))
  42         self.failIf(b1r2.canBeMergedWith(b1r1))
  43         self.failUnless(b1r2.canBeMergedWith(b1r2))
  44         self.failIf(b1r2.canBeMergedWith(b2r2))
  45         self.failIf(b1r2.canBeMergedWith(b1r1p1))
  46
  47         self.failIf(b1r1p1.canBeMergedWith(b1))
  48         self.failIf(b1r1p1.canBeMergedWith(b1r1))
  49         self.failIf(b1r1p1.canBeMergedWith(b1r2))
  50         self.failIf(b1r1p1.canBeMergedWith(b2r2))
  51         self.failIf(b1r1p1.canBeMergedWith(b1c1))
  52
  53         self.failIf(b1c1.canBeMergedWith(b1))
  54         self.failIf(b1c1.canBeMergedWith(b1r1))
  55         self.failIf(b1c1.canBeMergedWith(b1r2))
  56         self.failIf(b1c1.canBeMergedWith(b2r2))
  57         self.failIf(b1c1.canBeMergedWith(b1r1p1))
  58         self.failUnless(b1c1.canBeMergedWith(b1c1))
  59         self.failUnless(b1c1.canBeMergedWith(b1c2))
  60
  61         sm = b1.mergeWith([])
  62         self.failUnlessEqual(sm.branch, "branch1")
  63         self.failUnlessEqual(sm.revision, None)
  64         self.failUnlessEqual(sm.patch, None)
  65         self.failUnlessEqual(sm.changes, ())
  66
  67         ss = b1r1.mergeWith([b1r1])
  68         self.failUnlessEqual(ss, S("branch1", "rev1", None, None))
  69         why = b1r1.mergeReasons([b1r1])
  70         self.failUnlessEqual(why, "why2")
  71         why = b1r1.mergeReasons([b1r1a])
  72         self.failUnlessEqual(why, "why2, why not")
  73
  74         ss = b1c1.mergeWith([b1c2])
  75         self.failUnlessEqual(ss, S("branch1", None, None, [c1,c2,c3,c4,c5,c6]))
  76         why = b1c1.mergeReasons([b1c2])
  77         self.failUnlessEqual(why, "changes")
  78
  79
  80 class FakeBuilder:
  81     name = "fake"
  82     def __init__(self):
  83         self.requests = []
  84     def submitBuildRequest(self, req):
  85         self.requests.append(req)
  86
  87
  88 class Set(unittest.TestCase):
  89     def testBuildSet(self):
  90         S = buildset.BuildSet
  91         a,b = FakeBuilder(), FakeBuilder()
  92
  93         # two builds, the first one fails, the second one succeeds. The
  94         # waitUntilSuccess watcher fires as soon as the first one fails,
  95         # while the waitUntilFinished watcher doesn't fire until all builds
  96         # are complete.
  97
  98         source = sourcestamp.SourceStamp()
  99         s = S(["a","b"], source, "forced build")
 100         s.start([a,b])
 101         self.failUnlessEqual(len(a.requests), 1)
 102         self.failUnlessEqual(len(b.requests), 1)
 103         r1 = a.requests[0]
 104         self.failUnlessEqual(r1.reason, s.reason)
 105         self.failUnlessEqual(r1.source, s.source)
 106
 107         st = s.status
 108         self.failUnlessEqual(st.getSourceStamp(), source)
 109         self.failUnlessEqual(st.getReason(), "forced build")
 110         self.failUnlessEqual(st.getBuilderNames(), ["a","b"])
 111         self.failIf(st.isFinished())
 112         brs = st.getBuildRequests()
 113         self.failUnlessEqual(len(brs), 2)
 114
 115         res = []
 116         d1 = s.waitUntilSuccess()
 117         d1.addCallback(lambda r: res.append(("success", r)))
 118         d2 = s.waitUntilFinished()
 119         d2.addCallback(lambda r: res.append(("finished", r)))
 120
 121         self.failUnlessEqual(res, [])
 122
 123         # the first build finishes here, with FAILURE
 124         builderstatus_a = builder.BuilderStatus("a")
 125         bsa = builder.BuildStatus(builderstatus_a, 1)
 126         bsa.setResults(builder.FAILURE)
 127         a.requests[0].finished(bsa)
 128
 129         # any FAILURE flunks the BuildSet immediately, so the
 130         # waitUntilSuccess deferred fires right away. However, the
 131         # waitUntilFinished deferred must wait until all builds have
 132         # completed.
 133         self.failUnlessEqual(len(res), 1)
 134         self.failUnlessEqual(res[0][0], "success")
 135         bss = res[0][1]
 136         self.failUnless(interfaces.IBuildSetStatus(bss, None))
 137         self.failUnlessEqual(bss.getResults(), builder.FAILURE)
 138
 139         # here we finish the second build
 140         builderstatus_b = builder.BuilderStatus("b")
 141         bsb = builder.BuildStatus(builderstatus_b, 1)
 142         bsb.setResults(builder.SUCCESS)
 143         b.requests[0].finished(bsb)
 144
 145         # .. which ought to fire the waitUntilFinished deferred
 146         self.failUnlessEqual(len(res), 2)
 147         self.failUnlessEqual(res[1][0], "finished")
 148         self.failUnlessEqual(res[1][1], bss)
 149
 150         # and finish the BuildSet overall
 151         self.failUnless(st.isFinished())
 152         self.failUnlessEqual(st.getResults(), builder.FAILURE)
 153
 154     def testSuccess(self):
 155         S = buildset.BuildSet
 156         a,b = FakeBuilder(), FakeBuilder()
 157         # this time, both builds succeed
 158
 159         source = sourcestamp.SourceStamp()
 160         s = S(["a","b"], source, "forced build")
 161         s.start([a,b])
 162
 163         st = s.status
 164         self.failUnlessEqual(st.getSourceStamp(), source)
 165         self.failUnlessEqual(st.getReason(), "forced build")
 166         self.failUnlessEqual(st.getBuilderNames(), ["a","b"])
 167         self.failIf(st.isFinished())
 168
 169         builderstatus_a = builder.BuilderStatus("a")
 170         bsa = builder.BuildStatus(builderstatus_a, 1)
 171         bsa.setResults(builder.SUCCESS)
 172         a.requests[0].finished(bsa)
 173
 174         builderstatus_b = builder.BuilderStatus("b")
 175         bsb = builder.BuildStatus(builderstatus_b, 1)
 176         bsb.setResults(builder.SUCCESS)
 177         b.requests[0].finished(bsb)
 178
 179         self.failUnless(st.isFinished())
 180         self.failUnlessEqual(st.getResults(), builder.SUCCESS)
 181