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