def testBuildLocksAcquired(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) b.builder.botmaster = FakeMaster() slavebuilder = Mock() status = Mock() l = SlaveLock("lock") claimCount = [0] lock_access = l.access("counting") l.access = lambda mode: lock_access real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder) def claim(owner, access): claimCount[0] += 1 return real_lock.old_claim(owner, access) real_lock.old_claim = real_lock.claim real_lock.claim = claim b.setLocks([l]) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS b.setStepFactories([(step, {})]) b.startBuild(status, None, slavebuilder) self.assertEqual(b.result, SUCCESS) self.assert_(("startStep", (b.remote,), {}) in step.method_calls) self.assertEquals(claimCount[0], 1)
def testStopBuild(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) step = Mock() step.return_value = step b.setStepFactories([(step, {})]) slavebuilder = Mock() status = Mock() def startStep(*args, **kw): # Now interrupt the build b.stopBuild("stop it") return defer.Deferred() step.startStep = startStep b.startBuild(status, None, slavebuilder) self.assertEqual(b.result, EXCEPTION) self.assert_(("interrupt", ("stop it",), {}) in step.method_calls)
def testStopBuildWaitingForLocks(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) b.builder.botmaster = FakeMaster() slavebuilder = Mock() status = Mock() l = SlaveLock('lock') lock_access = l.access('counting') l.access = lambda mode: lock_access real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder) b.setLocks([l]) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS step.alwaysRun = False b.setStepFactories([(step, {})]) real_lock.claim(Mock(), l.access('counting')) def acquireLocks(res=None): retval = Build.acquireLocks(b, res) b.stopBuild('stop it') return retval b.acquireLocks = acquireLocks b.startBuild(status, None, slavebuilder) self.assert_( ('startStep', (b.remote,), {}) not in step.method_calls) self.assert_(b.currentStep is None) self.assertEqual(b.result, EXCEPTION) self.assert_( ('interrupt', ('stop it',), {}) not in step.method_calls)
def testBuildWaitingForLocks(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) b.builder.botmaster = FakeMaster() slavebuilder = Mock() status = Mock() l = SlaveLock('lock') claimCount = [0] lock_access = l.access('counting') l.access = lambda mode: lock_access real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder) def claim(owner, access): claimCount[0] += 1 return real_lock.old_claim(owner, access) real_lock.old_claim = real_lock.claim real_lock.claim = claim b.setLocks([l]) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS b.setStepFactories([(step, {})]) real_lock.claim(Mock(), l.access('counting')) b.startBuild(status, None, slavebuilder) self.assert_( ('startStep', (b.remote,), {}) not in step.method_calls) self.assertEquals(claimCount[0], 1) self.assert_(b.currentStep is None) self.assert_(b._acquiringLock is not None)
class TestSetupProperties_SingleSource(TestReactorMixin, unittest.TestCase): """ Test that the property values, based on the available requests, are initialized properly """ def setUp(self): self.setup_test_reactor() self.props = {} self.r = FakeRequest() self.r.sources = [] self.r.sources.append(FakeSource()) self.r.sources[0].changes = [FakeChange()] self.r.sources[0].repository = "http://svn-repo-A" self.r.sources[0].codebase = "A" self.r.sources[0].branch = "develop" self.r.sources[0].revision = "12345" self.build = Build([self.r]) self.build.setStepFactories([]) self.builder = FakeBuilder(fakemaster.make_master(self, wantData=True)) self.build.setBuilder(self.builder) # record properties that will be set self.build.properties.setProperty = self.setProperty def setProperty(self, n, v, s, runtime=False): if s not in self.props: self.props[s] = {} if not self.props[s]: self.props[s] = {} self.props[s][n] = v def test_properties_codebase(self): Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources) codebase = self.props["Build"]["codebase"] self.assertEqual(codebase, "A") def test_properties_repository(self): Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources) repository = self.props["Build"]["repository"] self.assertEqual(repository, "http://svn-repo-A") def test_properties_revision(self): Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources) revision = self.props["Build"]["revision"] self.assertEqual(revision, "12345") def test_properties_branch(self): Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources) branch = self.props["Build"]["branch"] self.assertEqual(branch, "develop") def test_property_project(self): Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources) project = self.props["Build"]["project"] self.assertEqual(project, '')
class TestBuildProperties(unittest.TestCase): """ Test that a Build has the necessary L{IProperties} methods, and that they properly delegate to the C{build_status} attribute - so really just a test of the L{IProperties} adapter. """ def setUp(self): class FakeBuildStatus(Mock): implements(interfaces.IProperties) r = FakeRequest() r.sources = [FakeSource()] r.sources[0].changes = [FakeChange()] r.sources[0].revision = "12345" self.master = fakemaster.make_master(wantData=True, testcase=self) self.slave = slave.FakeSlave(self.master) self.slave.attached(None) self.slavebuilder = Mock(name='slavebuilder') self.slavebuilder.slave = self.slave self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder( fakemaster.make_master(wantData=True, testcase=self)) self.build.setBuilder(self.builder) self.build_status = FakeBuildStatus() self.build.startBuild(self.build_status, None, self.slavebuilder) def test_getProperty(self): self.build.getProperty('x') self.build_status.getProperty.assert_called_with('x', None) def test_getProperty_default(self): self.build.getProperty('x', 'nox') self.build_status.getProperty.assert_called_with('x', 'nox') def test_setProperty(self): self.build.setProperty('n', 'v', 's') self.build_status.setProperty.assert_called_with('n', 'v', 's', runtime=True) def test_hasProperty(self): self.build_status.hasProperty.return_value = True self.assertTrue(self.build.hasProperty('p')) self.build_status.hasProperty.assert_called_with('p') def test_has_key(self): self.build_status.has_key.return_value = True # getattr because pep8 doesn't like calls to has_key self.assertTrue(getattr(self.build, 'has_key')('p')) # has_key calls through to hasProperty self.build_status.hasProperty.assert_called_with('p') def test_render(self): self.build.render("xyz") self.build_status.render.assert_called_with("xyz")
class TestSetupProperties_SingleSource(unittest.TestCase): """ Test that the property values, based on the available requests, are initialized properly """ def setUp(self): self.props = {} r = FakeRequest() r.sources = [] r.sources.append(FakeSource()) r.sources[0].changes = [FakeChange()] r.sources[0].repository = "http://svn-repo-A" r.sources[0].codebase = "A" r.sources[0].branch = "develop" r.sources[0].revision = "12345" self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder( fakemaster.make_master(wantData=True, testcase=self)) self.build.setBuilder(self.builder) self.build.build_status = FakeBuildStatus() # record properties that will be set self.build.properties.setProperty = self.setProperty def setProperty(self, n, v, s, runtime=False): if s not in self.props: self.props[s] = {} if not self.props[s]: self.props[s] = {} self.props[s][n] = v def test_properties_codebase(self): self.build.setupOwnProperties() codebase = self.props["Build"]["codebase"] self.assertEqual(codebase, "A") def test_properties_repository(self): self.build.setupOwnProperties() repository = self.props["Build"]["repository"] self.assertEqual(repository, "http://svn-repo-A") def test_properties_revision(self): self.build.setupOwnProperties() revision = self.props["Build"]["revision"] self.assertEqual(revision, "12345") def test_properties_branch(self): self.build.setupOwnProperties() branch = self.props["Build"]["branch"] self.assertEqual(branch, "develop") def test_property_project(self): self.build.setupOwnProperties() project = self.props["Build"]["project"] self.assertEqual(project, '')
class TestSetupProperties_SingleSource(unittest.TestCase): """ Test that the property values, based on the available requests, are initialized properly """ def setUp(self): self.props = {} r = FakeRequest() r.sources = [] r.sources.append(FakeSource()) r.sources[0].changes = [FakeChange()] r.sources[0].repository = "http://svn-repo-A" r.sources[0].codebase = "A" r.sources[0].branch = "develop" r.sources[0].revision = "12345" self.build = Build([r]) self.build.setStepFactories([]) self.builder = Mock() self.build.setBuilder(self.builder) self.build.build_status = FakeBuildStatus() # record properties that will be set self.build.build_status.setProperty = self.setProperty def setProperty(self, n, v, s, runtime=False): if s not in self.props: self.props[s] = {} if not self.props[s]: self.props[s] = {} self.props[s][n] = v def test_properties_codebase(self): self.build.setupProperties() codebase = self.props["Build"]["codebase"] self.assertEqual(codebase, "A") def test_properties_repository(self): self.build.setupProperties() repository = self.props["Build"]["repository"] self.assertEqual(repository, "http://svn-repo-A") def test_properties_revision(self): self.build.setupProperties() revision = self.props["Build"]["revision"] self.assertEqual(revision, "12345") def test_properties_branch(self): self.build.setupProperties() branch = self.props["Build"]["branch"] self.assertEqual(branch, "develop") def test_property_project(self): self.build.setupProperties() project = self.props["Build"]["project"] self.assertEqual(project, '')
def testBuildLocksOrder(self): """Test that locks are acquired in FIFO order; specifically that counting locks cannot jump ahead of exclusive locks""" eBuild = self.build cBuilder = FakeBuilder(self.master) cBuild = Build([self.request]) cBuild.setBuilder(cBuilder) eWorker = Mock() cWorker = Mock() eWorker.worker = self.worker cWorker.worker = self.worker eWorker.prepare = cWorker.prepare = lambda _: True eWorker.ping = cWorker.ping = lambda: True l = WorkerLock('lock', 2) claimLog = [] realLock = self.master.botmaster.getLockByID(l).getLock(self.worker) def claim(owner, access): claimLog.append(owner) return realLock.oldClaim(owner, access) realLock.oldClaim = realLock.claim realLock.claim = claim eBuild.setLocks([l.access('exclusive')]) cBuild.setLocks([l.access('counting')]) fakeBuild = Mock() fakeBuildAccess = l.access('counting') realLock.claim(fakeBuild, fakeBuildAccess) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS eBuild.setStepFactories([FakeStepFactory(step)]) cBuild.setStepFactories([FakeStepFactory(step)]) e = eBuild.startBuild(FakeBuildStatus(), eWorker) c = cBuild.startBuild(FakeBuildStatus(), cWorker) d = defer.DeferredList([e, c]) realLock.release(fakeBuild, fakeBuildAccess) def check(ign): self.assertEqual(eBuild.results, SUCCESS) self.assertEqual(cBuild.results, SUCCESS) self.assertEqual(claimLog, [fakeBuild, eBuild, cBuild]) d.addCallback(check) return d
def testBuildLocksOrder(self): """Test that locks are acquired in FIFO order; specifically that counting locks cannot jump ahead of exclusive locks""" eBuild = self.build cBuilder = FakeBuilder(self.master) cBuild = Build([self.request]) cBuild.setBuilder(cBuilder) eWorker = Mock() cWorker = Mock() eWorker.worker = self.worker cWorker.worker = self.worker eWorker.prepare = cWorker.prepare = lambda _: True eWorker.ping = cWorker.ping = lambda: True l = WorkerLock("lock", 2) claimLog = [] realLock = self.master.botmaster.getLockByID(l).getLock(self.worker) def claim(owner, access): claimLog.append(owner) return realLock.oldClaim(owner, access) realLock.oldClaim = realLock.claim realLock.claim = claim eBuild.setLocks([l.access("exclusive")]) cBuild.setLocks([l.access("counting")]) fakeBuild = Mock() fakeBuildAccess = l.access("counting") realLock.claim(fakeBuild, fakeBuildAccess) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS eBuild.setStepFactories([FakeStepFactory(step)]) cBuild.setStepFactories([FakeStepFactory(step)]) e = eBuild.startBuild(FakeBuildStatus(), eWorker) c = cBuild.startBuild(FakeBuildStatus(), cWorker) d = defer.DeferredList([e, c]) realLock.release(fakeBuild, fakeBuildAccess) def check(ign): self.assertEqual(eBuild.results, SUCCESS) self.assertEqual(cBuild.results, SUCCESS) self.assertEqual(claimLog, [fakeBuild, eBuild, cBuild]) d.addCallback(check) return d
def testBuildLocksOrder(self): """Test that locks are acquired in FIFO order; specifically that counting locks cannot jump ahead of exclusive locks""" eBuild = self.build cBuilder = self.createBuilder() cBuild = Build([self.request]) cBuild.setBuilder(cBuilder) eSlavebuilder = Mock() cSlavebuilder = Mock() slave = eSlavebuilder.slave cSlavebuilder.slave = slave l = SlaveLock('lock', 2) claimLog = [] realLock = self.master.botmaster.getLockByID(l).getLock(slave) def claim(owner, access): claimLog.append(owner) return realLock.oldClaim(owner, access) realLock.oldClaim = realLock.claim realLock.claim = claim eBuild.setLocks([l.access('exclusive')]) cBuild.setLocks([l.access('counting')]) fakeBuild = Mock() fakeBuildAccess = l.access('counting') realLock.claim(fakeBuild, fakeBuildAccess) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS eBuild.setStepFactories([FakeStepFactory(step)]) cBuild.setStepFactories([FakeStepFactory(step)]) e = eBuild.startBuild(FakeBuildStatus(), None, eSlavebuilder) c = cBuild.startBuild(FakeBuildStatus(), None, cSlavebuilder) d = defer.DeferredList([e, c]) realLock.release(fakeBuild, fakeBuildAccess) def check(ign): self.assertEqual(eBuild.result, NOT_REBUILT) self.assertEqual(cBuild.result, NOT_REBUILT) self.assertEquals(claimLog, [fakeBuild, eBuild, cBuild]) d.addCallback(check) return d
def testBuildLocksOrder(self): """Test that locks are acquired in FIFO order; specifically that counting locks cannot jump ahead of exclusive locks""" eBuild = self.build cBuilder = self.createBuilder() cBuild = Build([self.request]) cBuild.setBuilder(cBuilder) eSlavebuilder = Mock() cSlavebuilder = Mock() slave = eSlavebuilder.slave cSlavebuilder.slave = slave l = SlaveLock('lock', 2) claimLog = [] realLock = self.master.botmaster.getLockByID(l).getLock(slave) def claim(owner, access): claimLog.append(owner) return realLock.oldClaim(owner, access) realLock.oldClaim = realLock.claim realLock.claim = claim eBuild.setLocks([l.access('exclusive')]) cBuild.setLocks([l.access('counting')]) fakeBuild = Mock() fakeBuildAccess = l.access('counting') realLock.claim(fakeBuild, fakeBuildAccess) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS eBuild.setStepFactories([FakeStepFactory(step)]) cBuild.setStepFactories([FakeStepFactory(step)]) e = eBuild.startBuild(FakeBuildStatus(), None, eSlavebuilder) c = cBuild.startBuild(FakeBuildStatus(), None, cSlavebuilder) d = defer.DeferredList([e, c]) realLock.release(fakeBuild, fakeBuildAccess) def check(ign): self.assertEqual(eBuild.result, SUCCESS) self.assertEqual(cBuild.result, SUCCESS) self.assertEquals(claimLog, [fakeBuild, eBuild, cBuild]) d.addCallback(check) return d
def testBuildLocksOrder(self): """Test that locks are acquired in FIFO order; specifically that counting locks cannot jump ahead of exclusive locks""" eBuild = self.build cBuilder = FakeBuilder(self.master) cBuild = Build([self.request]) cBuild.setBuilder(cBuilder) eWorker = Mock() cWorker = Mock() eWorker.worker = self.worker cWorker.worker = self.worker eWorker.substantiate_if_needed = cWorker.substantiate_if_needed = lambda _: True eWorker.ping = cWorker.ping = lambda: True lock = WorkerLock('lock', 2) claimLog = [] real_workerlock = yield self.master.botmaster.getLockByID(lock, 0) realLock = real_workerlock.getLockForWorker(self.worker.workername) def claim(owner, access): claimLog.append(owner) return realLock.oldClaim(owner, access) realLock.oldClaim = realLock.claim realLock.claim = claim yield eBuild.setLocks([lock.access('exclusive')]) yield cBuild.setLocks([lock.access('counting')]) fakeBuild = Mock() fakeBuildAccess = lock.access('counting') realLock.claim(fakeBuild, fakeBuildAccess) step = FakeBuildStep() eBuild.setStepFactories([FakeStepFactory(step)]) cBuild.setStepFactories([FakeStepFactory(step)]) e = eBuild.startBuild(eWorker) c = cBuild.startBuild(cWorker) d = defer.DeferredList([e, c]) realLock.release(fakeBuild, fakeBuildAccess) yield d self.assertEqual(eBuild.results, SUCCESS) self.assertEqual(cBuild.results, SUCCESS) self.assertEqual(claimLog, [fakeBuild, eBuild, cBuild])
def testAlwaysRunStepStopBuild(self): """Test that steps marked with alwaysRun=True still get run even if the build is stopped.""" # Create a build with 2 steps, the first one will get interrupted, and # the second one is marked with alwaysRun=True r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) step1 = Mock() step1.return_value = step1 step1.alwaysRun = False step2 = Mock() step2.return_value = step2 step2.alwaysRun = True b.setStepFactories([(step1, {}), (step2, {})]) slavebuilder = Mock() status = Mock() def startStep1(*args, **kw): # Now interrupt the build b.stopBuild("stop it") return defer.succeed(SUCCESS) step1.startStep = startStep1 step1.stepDone.return_value = False step2Started = [False] def startStep2(*args, **kw): step2Started[0] = True return defer.succeed(SUCCESS) step2.startStep = startStep2 step1.stepDone.return_value = False d = b.startBuild(status, None, slavebuilder) def check(ign): self.assertEqual(b.result, EXCEPTION) self.assert_(("interrupt", ("stop it",), {}) in step1.method_calls) self.assert_(step2Started[0]) d.addCallback(check) return d
class TestBuildProperties(unittest.TestCase): """ Test that a Build has the necessary L{IProperties} methods, and that they properly delegate to the C{build_status} attribute - so really just a test of the L{IProperties} adapter. """ def setUp(self): r = FakeRequest() r.sources = [FakeSource()] r.sources[0].changes = [FakeChange()] r.sources[0].revision = "12345" self.build = Build([r]) self.build.setStepFactories([]) self.builder = Mock() self.builder.botmaster.master.config.globalFactory = {} self.build.setBuilder(self.builder) self.build_status = FakeBuildStatus() self.build.startBuild(self.build_status, None, Mock()) def test_getProperty(self): self.build.getProperty('x') self.build_status.getProperty.assert_called_with('x', None) def test_getProperty_default(self): self.build.getProperty('x', 'nox') self.build_status.getProperty.assert_called_with('x', 'nox') def test_setProperty(self): self.build.setProperty('n', 'v', 's') self.build_status.setProperty.assert_called_with('n', 'v', 's', runtime=True) def test_hasProperty(self): self.build_status.hasProperty.return_value = True self.assertTrue(self.build.hasProperty('p')) self.build_status.hasProperty.assert_called_with('p') def test_has_key(self): self.build_status.has_key.return_value = True self.assertTrue(self.build.has_key('p')) # has_key calls through to hasProperty self.build_status.hasProperty.assert_called_with('p') def test_render(self): self.build.render("xyz") self.build_status.render.assert_called_with("xyz")
class TestBuildProperties(unittest.TestCase): """ Test that a Build has the necessary L{IProperties} methods, and that they properly delegate to the C{build_status} attribute - so really just a test of the L{IProperties} adapter. """ def setUp(self): r = FakeRequest() r.sources = [FakeSource()] r.sources[0].changes = [FakeChange()] r.sources[0].revision = "12345" self.build = Build([r]) self.build.setStepFactories([]) self.builder = Mock() self.build.setBuilder(self.builder) self.build_status = FakeBuildStatus() self.build.startBuild(self.build_status, None, Mock()) def test_getProperty(self): self.build.getProperty('x') self.build_status.getProperty.assert_called_with('x', None) def test_getProperty_default(self): self.build.getProperty('x', 'nox') self.build_status.getProperty.assert_called_with('x', 'nox') def test_setProperty(self): self.build.setProperty('n', 'v', 's') self.build_status.setProperty.assert_called_with('n', 'v', 's', runtime=True) def test_hasProperty(self): self.build_status.hasProperty.return_value = True self.assertTrue(self.build.hasProperty('p')) self.build_status.hasProperty.assert_called_with('p') def test_has_propkey(self): self.build_status.has_propkey.return_value = True self.assertTrue(self.build.has_propkey('p')) # has_propkey calls through to hasProperty self.build_status.hasProperty.assert_called_with('p') def test_render(self): self.build.render("xyz") self.build_status.render.assert_called_with("xyz")
def testAlwaysRunStepStopBuild(self): """Test that steps marked with alwaysRun=True still get run even if the build is stopped.""" # Create a build with 2 steps, the first one will get interrupted, and # the second one is marked with alwaysRun=True r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) step1 = Mock() step1.return_value = step1 step1.alwaysRun = False step2 = Mock() step2.return_value = step2 step2.alwaysRun = True b.setStepFactories([ (step1, {}), (step2, {}), ]) slavebuilder = Mock() status = Mock() def startStep1(*args, **kw): # Now interrupt the build b.stopBuild("stop it") return defer.succeed( SUCCESS ) step1.startStep = startStep1 step1.stepDone.return_value = False step2Started = [False] def startStep2(*args, **kw): step2Started[0] = True return defer.succeed( SUCCESS ) step2.startStep = startStep2 step1.stepDone.return_value = False d = b.startBuild(status, None, slavebuilder) def check(ign): self.assertEqual(b.result, EXCEPTION) self.assert_( ('interrupt', ('stop it',), {}) in step1.method_calls) self.assert_(step2Started[0]) d.addCallback(check) return d
class TestSetupProperties_MultipleSources(unittest.TestCase): """ Test that the property values, based on the available requests, are initialized properly """ def setUp(self): self.props = {} r = FakeRequest() r.sources = [] r.sources.append(FakeSource()) r.sources[0].changes = [FakeChange()] r.sources[0].repository = "http://svn-repo-A" r.sources[0].codebase = "A" r.sources[0].branch = "develop" r.sources[0].revision = "12345" r.sources.append(FakeSource()) r.sources[1].changes = [FakeChange()] r.sources[1].repository = "http://svn-repo-B" r.sources[1].codebase = "B" r.sources[1].revision = "34567" self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder( fakemaster.make_master(wantData=True, testcase=self)) self.build.setBuilder(self.builder) self.build.build_status = FakeBuildStatus() # record properties that will be set self.build.properties.setProperty = self.setProperty def setProperty(self, n, v, s, runtime=False): if s not in self.props: self.props[s] = {} if not self.props[s]: self.props[s] = {} self.props[s][n] = v def test_sourcestamp_properties_not_set(self): self.build.setupProperties() self.assertTrue("codebase" not in self.props["Build"]) self.assertTrue("revision" not in self.props["Build"]) self.assertTrue("branch" not in self.props["Build"]) self.assertTrue("project" not in self.props["Build"]) self.assertTrue("repository" not in self.props["Build"])
class TestSetupProperties_MultipleSources(unittest.TestCase): """ Test that the property values, based on the available requests, are initialized properly """ def setUp(self): self.props = {} r = FakeRequest() r.sources = [] r.sources.append(FakeSource()) r.sources[0].changes = [FakeChange()] r.sources[0].repository = "http://svn-repo-A" r.sources[0].codebase = "A" r.sources[0].branch = "develop" r.sources[0].revision = "12345" r.sources.append(FakeSource()) r.sources[1].changes = [FakeChange()] r.sources[1].repository = "http://svn-repo-B" r.sources[1].codebase = "B" r.sources[1].revision = "34567" self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder( fakemaster.make_master(wantData=True, testcase=self)) self.build.setBuilder(self.builder) self.build.build_status = FakeBuildStatus() # record properties that will be set self.build.properties.setProperty = self.setProperty def setProperty(self, n, v, s, runtime=False): if s not in self.props: self.props[s] = {} if not self.props[s]: self.props[s] = {} self.props[s][n] = v def test_sourcestamp_properties_not_set(self): self.build.setupOwnProperties() self.assertNotIn("codebase", self.props["Build"]) self.assertNotIn("revision", self.props["Build"]) self.assertNotIn("branch", self.props["Build"]) self.assertNotIn("project", self.props["Build"]) self.assertNotIn("repository", self.props["Build"])
def testRunSuccessfulBuild(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) step = Mock() step.return_value = step step.startStep.return_value = SUCCESS b.setStepFactories([(step, {})]) slavebuilder = Mock() status = Mock() b.startBuild(status, None, slavebuilder) self.assertEqual(b.result, SUCCESS) self.assert_( ('startStep', (b.remote,), {}) in step.method_calls)
class TestSetupProperties_MultipleSources(TestReactorMixin, unittest.TestCase): """ Test that the property values, based on the available requests, are initialized properly """ def setUp(self): self.setUpTestReactor() self.props = {} self.r = FakeRequest() self.r.sources = [] self.r.sources.append(FakeSource()) self.r.sources[0].changes = [FakeChange()] self.r.sources[0].repository = "http://svn-repo-A" self.r.sources[0].codebase = "A" self.r.sources[0].branch = "develop" self.r.sources[0].revision = "12345" self.r.sources.append(FakeSource()) self.r.sources[1].changes = [FakeChange()] self.r.sources[1].repository = "http://svn-repo-B" self.r.sources[1].codebase = "B" self.r.sources[1].revision = "34567" self.build = Build([self.r]) self.build.setStepFactories([]) self.builder = FakeBuilder(fakemaster.make_master(self, wantData=True)) self.build.setBuilder(self.builder) # record properties that will be set self.build.properties.setProperty = self.setProperty def setProperty(self, n, v, s, runtime=False): if s not in self.props: self.props[s] = {} if not self.props[s]: self.props[s] = {} self.props[s][n] = v def test_sourcestamp_properties_not_set(self): Build.setupBuildProperties(self.build.getProperties(), [self.r], self.r.sources) self.assertNotIn("codebase", self.props["Build"]) self.assertNotIn("revision", self.props["Build"]) self.assertNotIn("branch", self.props["Build"]) self.assertNotIn("project", self.props["Build"]) self.assertNotIn("repository", self.props["Build"])
def testStopBuildWaitingForStepLocks(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) b.builder.botmaster = FakeMaster() slavebuilder = Mock() status = Mock() l = SlaveLock("lock") lock_access = l.access("counting") l.access = lambda mode: lock_access real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder) step = LoggingBuildStep(locks=[lock_access]) def factory(*args): return step b.setStepFactories([(factory, {})]) real_lock.claim(Mock(), l.access("counting")) gotLocks = [False] def acquireLocks(res=None): gotLocks[0] = True retval = LoggingBuildStep.acquireLocks(step, res) self.assert_(b.currentStep is step) b.stopBuild("stop it") return retval step.acquireLocks = acquireLocks step.setStepStatus = Mock() step.step_status = Mock() step.step_status.addLog().chunkSize = 10 step.step_status.getLogs.return_value = [] b.startBuild(status, None, slavebuilder) self.assertEqual(gotLocks, [True]) self.assert_(("stepStarted", (), {}) in step.step_status.method_calls) self.assertEqual(b.result, EXCEPTION)
def testStopBuildWaitingForStepLocks(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) b.builder.botmaster = FakeMaster() slavebuilder = Mock() status = Mock() l = SlaveLock('lock') lock_access = l.access('counting') l.access = lambda mode: lock_access real_lock = b.builder.botmaster.getLockByID(l).getLock(slavebuilder) step = LoggingBuildStep(locks=[lock_access]) def factory(*args): return step b.setStepFactories([(factory, {})]) real_lock.claim(Mock(), l.access('counting')) gotLocks = [False] def acquireLocks(res=None): gotLocks[0] = True retval = LoggingBuildStep.acquireLocks(step, res) self.assert_(b.currentStep is step) b.stopBuild('stop it') return retval step.acquireLocks = acquireLocks step.setStepStatus = Mock() step.step_status = Mock() step.step_status.addLog().chunkSize = 10 step.step_status.getLogs.return_value = [] b.startBuild(status, None, slavebuilder) self.assertEqual(gotLocks, [True]) self.assert_(('stepStarted', (), {}) in step.step_status.method_calls) self.assertEqual(b.result, EXCEPTION)
def testStopBuild(self): r = FakeRequest() b = Build([r]) b.setBuilder(Mock()) step = Mock() step.return_value = step b.setStepFactories([(step, {})]) slavebuilder = Mock() status = Mock() def startStep(*args, **kw): # Now interrupt the build b.stopBuild("stop it") return defer.Deferred() step.startStep = startStep b.startBuild(status, None, slavebuilder) self.assertEqual(b.result, EXCEPTION) self.assert_( ('interrupt', ('stop it',), {}) in step.method_calls)
class TestTrigger(steps.BuildStepMixin, unittest.TestCase): def setUp(self): return self.setUpBuildStep() def tearDown(self): return self.tearDownBuildStep() def setupStep(self, step, sourcestampsInBuild=None, gotRevisionsInBuild=None, *args, **kwargs): sourcestamps = sourcestampsInBuild or [] got_revisions = gotRevisionsInBuild or {} steps.BuildStepMixin.setupStep(self, step, *args, **kwargs) # This step reaches deeply into a number of parts of Buildbot. That # should be fixed! # set up a buildmaster that knows about two fake schedulers, a and b m = fakemaster.make_master() self.build.builder.botmaster = m.botmaster m.db = fakedb.FakeDBConnector(self) m.status = master.Status(m) m.config.buildbotURL = "baseurl/" self.scheduler_a = a = FakeTriggerable(name='a') self.scheduler_b = b = FakeTriggerable(name='b') def allSchedulers(): return [ a, b ] m.allSchedulers = allSchedulers a.brids = {'A': 11} b.brids = {'B': 22} make_fake_br = lambda brid, name: fakedb.BuildRequest(id=brid, buildsetid=BRID_TO_BSID(brid), buildername=name) make_fake_build = lambda brid: fakedb.Build(brid=brid, id=BRID_TO_BID(brid), number=BRID_TO_BUILD_NUMBER(brid)) m.db.insertTestData([ make_fake_br(11, "A"), make_fake_br(22, "B"), make_fake_build(11), make_fake_build(22), ]) def getAllSourceStamps(): return sourcestamps self.build.getAllSourceStamps = getAllSourceStamps def getAllGotRevisions(): return got_revisions self.build.build_status.getAllGotRevisions = getAllGotRevisions request = Mock() request.id = 1 self.build.requests = [request] self.exp_add_sourcestamp = None self.exp_a_trigger = None self.exp_b_trigger = None self.exp_added_urls = [] def runStep(self, expect_waitForFinish=False): d = steps.BuildStepMixin.runStep(self) if expect_waitForFinish: # the build doesn't finish until after a callLater, so this has the # effect of checking whether the deferred has been fired already; # it should not have been! early = [] d.addCallback(early.append) self.assertEqual(early, []) def check(_): self.assertEqual(self.scheduler_a.triggered_with, self.exp_a_trigger) self.assertEqual(self.scheduler_b.triggered_with, self.exp_b_trigger) self.assertEqual(self.step_status.addURL.call_args_list, self.exp_added_urls) if self.exp_add_sourcestamp: self.assertEqual(self.addSourceStamp_kwargs, self.exp_add_sourcestamp) d.addCallback(check) # pause runStep's completion until after any other callLater's are done def wait(_): d = defer.Deferred() reactor.callLater(0, d.callback, None) return d d.addCallback(wait) return d def expectTriggeredWith(self, a=None, b=None): self.exp_a_trigger = a self.exp_b_trigger = b def expectAddedSourceStamp(self, **kwargs): self.exp_add_sourcestamp = kwargs def expectTriggeredLinks(self, *args): def get_args(sch, name): label = lambda name, num: "%s #%d" % (name, num) url = lambda name, num: "baseurl/builders/%s/builds/%d" % (name, num ) num = BRID_TO_BUILD_NUMBER(sch.brids[name]) #returns the *args and **kwargs that will be called on addURL... # which is just addURL('label', 'url') return ( (label(name,num), url(name,num)) , {} ) if 'a' in args: self.exp_added_urls.append(get_args(self.scheduler_a, 'A')) if 'b' in args: self.exp_added_urls.append(get_args(self.scheduler_b, 'B')) # tests def test_no_schedulerNames(self): self.assertRaises(config.ConfigErrors, lambda : trigger.Trigger()) def test_sourceStamp_and_updateSourceStamp(self): self.assertRaises(config.ConfigErrors, lambda : trigger.Trigger(schedulerNames=['c'], sourceStamp=dict(x=1), updateSourceStamp=True)) def test_sourceStamps_and_updateSourceStamp(self): self.assertRaises(config.ConfigErrors, lambda : trigger.Trigger(schedulerNames=['c'], sourceStamps=[dict(x=1), dict(x=2)], updateSourceStamp=True)) def test_updateSourceStamp_and_alwaysUseLatest(self): self.assertRaises(config.ConfigErrors, lambda : trigger.Trigger(schedulerNames=['c'], updateSourceStamp=True, alwaysUseLatest=True)) def test_sourceStamp_and_alwaysUseLatest(self): self.assertRaises(config.ConfigErrors, lambda : trigger.Trigger(schedulerNames=['c'], sourceStamp=dict(x=1), alwaysUseLatest=True)) def test_sourceStamps_and_alwaysUseLatest(self): self.assertRaises(config.ConfigErrors, lambda : trigger.Trigger(schedulerNames=['c'], sourceStamps=[dict(x=1), dict(x=2)], alwaysUseLatest=True)) def test_simple(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], sourceStamps = {})) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_simple_failure(self): self.setupStep(trigger.Trigger(schedulerNames=['a'])) self.scheduler_a.result = FAILURE # not waitForFinish, so trigger step succeeds even though the build # didn't fail self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() @compat.usesFlushLoggedErrors def test_simple_exception(self): self.setupStep(trigger.Trigger(schedulerNames=['a'])) self.scheduler_a.exception = True self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) d = self.runStep() def flush(_): self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1) d.addCallback(flush) return d def test_bogus_scheduler(self): self.setupStep(trigger.Trigger(schedulerNames=['a', 'x'])) self.expectOutcome(result=FAILURE, status_text=['not valid scheduler:', 'x']) self.expectTriggeredWith(a=None) # a is not triggered! return self.runStep() def test_updateSourceStamp(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], updateSourceStamp=True), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ], gotRevisionsInBuild = {'': 23456}, ) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({'':{'codebase':'', 'repository': 'x', 'revision': 23456} }, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_updateSourceStamp_no_got_revision(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], updateSourceStamp=True), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ]) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({'':{'codebase':'', 'repository': 'x', 'revision': 11111} # uses old revision }, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_not_updateSourceStamp(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], updateSourceStamp=False), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ], gotRevisionsInBuild = {'': 23456}, ) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({'':{'codebase':'', 'repository': 'x', 'revision': 11111} }, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_updateSourceStamp_multiple_repositories(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], updateSourceStamp=True), sourcestampsInBuild = [ FakeSourceStamp(codebase='cb1', revision='12345'), FakeSourceStamp(codebase='cb2', revision='12345') ], gotRevisionsInBuild = {'cb1': 23456, 'cb2': 34567}, ) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({'cb1': {'codebase':'cb1', 'revision':23456}, 'cb2': {'codebase':'cb2', 'revision':34567} }, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_updateSourceStamp_prop_false(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], updateSourceStamp=properties.Property('usess')), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ], gotRevisionsInBuild = {'': 23456}, ) self.properties.setProperty('usess', False, 'me') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) # didn't use got_revision self.expectTriggeredWith(a=({'': { 'codebase':'', 'repository': 'x', 'revision': 11111 }}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_updateSourceStamp_prop_true(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], updateSourceStamp=properties.Property('usess')), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ], gotRevisionsInBuild = {'': 23456}, ) self.properties.setProperty('usess', True, 'me') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) # didn't use got_revision self.expectTriggeredWith(a=({'': { 'codebase':'', 'repository': 'x', 'revision': 23456 }}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_alwaysUseLatest(self): self.setupStep(trigger.Trigger(schedulerNames=['b'], alwaysUseLatest=True), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ]) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) # Do not pass setid self.expectTriggeredWith(b=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_alwaysUseLatest_prop_false(self): self.setupStep(trigger.Trigger(schedulerNames=['b'], alwaysUseLatest=properties.Property('aul')), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ]) self.properties.setProperty('aul', False, 'me') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) # didn't use latest self.expectTriggeredWith(b=({'': { 'codebase':'', 'repository': 'x', 'revision': 11111} }, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_alwaysUseLatest_prop_true(self): self.setupStep(trigger.Trigger(schedulerNames=['b'], alwaysUseLatest=properties.Property('aul')), sourcestampsInBuild = [FakeSourceStamp(codebase='', repository='x', revision=11111) ]) self.properties.setProperty('aul', True, 'me') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) # didn't use latest self.expectTriggeredWith(b=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_sourceStamp(self): ss = dict(revision=9876, branch='dev') self.setupStep(trigger.Trigger(schedulerNames=['b'], sourceStamp=ss)) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) self.expectTriggeredWith(b=({'': ss}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_set_of_sourceStamps(self): ss1 = dict(codebase='cb1', repository='r1', revision=9876, branch='dev') ss2 = dict(codebase='cb2',repository='r2', revision=5432, branch='dev') self.setupStep(trigger.Trigger(schedulerNames=['b'], sourceStamps=[ss1,ss2])) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) self.expectTriggeredWith(b=({'cb1':ss1, 'cb2':ss2}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_set_of_sourceStamps_override_build(self): ss1 = dict(codebase='cb1', repository='r1', revision=9876, branch='dev') ss2 = dict(codebase='cb2',repository='r2', revision=5432, branch='dev') ss3 = FakeSourceStamp(codebase='cb3', repository='r3', revision=1234, branch='dev') ss4 = FakeSourceStamp(codebase='cb4',repository='r4', revision=2345, branch='dev') self.setupStep(trigger.Trigger(schedulerNames=['b'], sourceStamps=[ss1,ss2]), sourcestampsInBuild=[ss3, ss4]) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) self.expectTriggeredWith(b=({'cb1':ss1, 'cb2':ss2}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_sourceStamp_prop(self): self.setupStep(trigger.Trigger(schedulerNames=['b'], sourceStamp=dict(revision=properties.Property('rev'), branch='dev'))) self.properties.setProperty('rev', 602, 'me') expected_ss = dict(revision=602, branch='dev') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'b'"]) self.expectTriggeredWith(b=({'': expected_ss}, {'stepname': ('Trigger', 'Trigger')}, 1)) return self.runStep() def test_waitForFinish(self): self.setupStep(trigger.Trigger(schedulerNames=['a', 'b'], waitForFinish=True)) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'", "'b'"]) self.expectTriggeredWith( a=({}, {'stepname': ('Trigger', 'Trigger')}, 1), b=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) self.expectTriggeredLinks('a','b') return self.runStep(expect_waitForFinish=True) def test_waitForFinish_failure(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], waitForFinish=True)) self.scheduler_a.result = FAILURE self.expectOutcome(result=DEPENDENCY_FAILURE, status_text=['Dependency failed to build.']) self.expectTriggeredWith(a=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) self.expectTriggeredLinks('a') return self.runStep(expect_waitForFinish=True) @compat.usesFlushLoggedErrors def test_waitForFinish_exception(self): self.setupStep(trigger.Trigger(schedulerNames=['a', 'b'], waitForFinish=True)) self.scheduler_b.exception = True self.expectOutcome(result=DEPENDENCY_FAILURE, status_text=['Dependency failed to build.']) self.expectTriggeredWith( a=({}, {'stepname': ('Trigger', 'Trigger')}, 1), b=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) self.expectTriggeredLinks('a') # b doesn't return a brid d = self.runStep(expect_waitForFinish=True) def flush(_): self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1) d.addCallback(flush) return d def test_set_properties(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], set_properties=dict(x=1, y=2))) self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({}, dict(stepname=('Trigger', 'Trigger'), x=(1, 'Trigger'), y=(2, 'Trigger')), 1)) return self.runStep() def test_set_properties_prop(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], set_properties=dict(x=properties.Property('X'), y=2))) self.properties.setProperty('X', 'xxx', 'here') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({}, dict(stepname=('Trigger', 'Trigger'), x=('xxx', 'Trigger'), y=(2, 'Trigger')), 1)) return self.runStep() def test_copy_properties(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], copy_properties=['a', 'b'])) self.properties.setProperty('a', 'A', 'AA') self.properties.setProperty('b', 'B', 'BB') self.properties.setProperty('c', 'C', 'CC') self.expectOutcome(result=SUCCESS, status_text=['Triggered:', "'a'"]) self.expectTriggeredWith(a=({}, dict(a=('A', 'Trigger'), b=('B', 'Trigger'), stepname=('Trigger', 'Trigger')), 1)) return self.runStep() def test_interrupt(self): self.setupStep(trigger.Trigger(schedulerNames=['a'], waitForFinish=True)) self.expectOutcome(result=INTERRUPTED, status_text=['Trigger', '(build was interrupted)']) self.expectTriggeredWith(a=({}, {'stepname': ('Trigger', 'Trigger')}, 1)) d = self.runStep(expect_waitForFinish=True) # interrupt before the callLater representing the Triggerable # schedulers completes self.step.interrupt(failure.Failure(RuntimeError('oh noes'))) return d @defer.inlineCallbacks def test_interruptConnectionLostShouldRetry(self): self.master = fakemaster.FakeMaster() self.master.maybeStartBuildsForSlave = lambda slave: True self.master.db = fakedb.FakeDBConnector(self) rows = [fakedb.SourceStampSet(id=1), fakedb.SourceStamp(id=1, sourcestampsetid=1, codebase='c', branch="az", repository="xz", revision="ww"), fakedb.Buildset(id=1, reason='because', sourcestampsetid=1), fakedb.BuildRequest(id=1, buildsetid=1, buildername="bldr", submitted_at=130000)] yield self.master.db.insertTestData(rows) self.master.status = master.Status(self.master) self.master.config.buildbotURL = "baseurl/" self.scheduler_a = a = FakeTriggerable(name='a') self.scheduler_b = b = FakeTriggerable(name='b') def allSchedulers(): return [a, b] self.master.allSchedulers = allSchedulers self.factory = factory.BuildFactory() self.step = trigger.Trigger(schedulerNames=['a'], waitForFinish=True) self.step.addCompleteLog = lambda x,y: True self.factory.addStep(self.step) config_args = dict(name="bldr", slavename="slv", builddir="bdir", slavebuilddir="sbdir", project='default', factory=self.factory) builder_config = config.BuilderConfig(**config_args) self.bldr = Builder(builder_config.name, _addServices=False) self.bldr.master = self.master self.bldr.botmaster = self.master.botmaster mastercfg = config.MasterConfig() mastercfg.builders = [ builder_config ] self.bldr.startService() yield self.bldr.reconfigService(mastercfg) def newBuild(buildrequests): self.build = Build(buildrequests) self.build.setStepFactories([fakebuild.FakeStepFactory(self.step)]) return self.build self.bldr.config.factory.newBuild = newBuild self.bldr.notifyRequestsRemoved = lambda x: True sb = Mock(spec=['isAvailable'], name='test-slave-1') sb.name = 'test-slave-1' sb.isAvailable.return_value = 1 sb.slave = Mock() sb.slave.updateStatusBuildFinished = lambda result, build: result sb.slave.properties = properties.Properties() sb.prepare = lambda x, y: True sb.ping = lambda timeout: True sb.buildStarted = lambda: True sb.buildFinished = lambda _: False sb.setSlaveIdle = lambda: False sb.remote = Mock() self.bldr.slaves.append(sb) self.assertEqual(self.master.db.buildrequests.claims, {}) from buildbot.process import buildrequestdistributor self.brd = buildrequestdistributor.BuildRequestDistributor(self.master.botmaster) self.brd.startService() yield self.brd._maybeStartBuildsOnBuilder(self.bldr) self.assertEqual(self.master.db.buildrequests.claims[1].brid, 1) self.build.build_status.saveYourself = lambda: True self.build.currentStep.start() self.build.lostRemote() self.assertEqual(self.master.db.buildrequests.claims, {}) if self.brd.running: self.brd.stopService() @defer.inlineCallbacks def test_TriggerStepMultiMasterMode(self): m = fakemaster.FakeMaster() m.maybeStartBuildsForSlave = lambda slave: True m.status = master.Status(m) m.config.buildbotURL = "baseurl/" m.config.multiMaster = True m.db = fakedb.FakeDBConnector(self) scheduler_a = FakeTriggerable(name='a') m.allSchedulers = lambda: [scheduler_a] def trigger_sch(sourcestamps = None, set_props=None, triggeredbybrid=None, reason=None): rows = [ fakedb.MasterConfig(id=1, buildbotURL="build-master-01/", objectid=1), fakedb.MasterConfig(id=2, buildbotURL="build-master-02/", objectid=2), fakedb.SourceStampSet(id=1), fakedb.SourceStamp(id=1, sourcestampsetid=1, codebase='c', branch="az", repository="xz", revision="ww"), fakedb.Buildset(id=1, reason='because', sourcestampsetid=1), fakedb.BuildRequest(id=1, buildsetid=1, buildername="builder1", submitted_at=130000), fakedb.BuildRequest(id=2, buildsetid=1, buildername="builder2", submitted_at=130000), fakedb.BuildRequestClaim(brid=1, objectid=2, claimed_at=130000), fakedb.BuildRequestClaim(brid=2, objectid=1, claimed_at=130000), fakedb.Build(id=1, number=1, brid=1), fakedb.Build(id=2, number=1, brid=2)] d = m.db.insertTestData(rows) d.addCallback(lambda _: (SUCCESS, {'builder1': 1L, 'builder2': 2L})) return d scheduler_a.trigger = trigger_sch self.step = trigger.Trigger(schedulerNames=['a'], waitForFinish=True) self.step.addCompleteLog = lambda x,y: True self.step.step_status = Mock() self.step.step_status.getLogs = lambda: [] self.expected_urls = [] self.step.step_status.addURL = lambda text, path, results=None: \ self.expected_urls.append({'text': text, 'path': path}) self.step.build = fakebuild.FakeBuild() self.step.build.builder.botmaster = m.botmaster self.step.build.getAllSourceStamps = lambda: [] self.step.build.build_status.getAllGotRevisions = lambda: {} request = Mock() request.id = 1 self.step.build.requests = [request] self.remote = Mock(name="SlaveBuilder(remote)") yield self.step.startStep(self.remote) self.assertEquals(len(self.expected_urls), 2) self.assertTrue({'text': 'builder1 #1', 'path': 'build-master-02/builders/builder1/builds/1'} in self.expected_urls) self.assertTrue({'text': 'builder1 #1', 'path': 'build-master-02/builders/builder1/builds/1'} in self.expected_urls)
class TestBuildProperties(unittest.TestCase): """ Test that a Build has the necessary L{IProperties} methods, and that they properly delegate to the C{build_status} attribute - so really just a test of the L{IProperties} adapter. """ def setUp(self): @implementer(interfaces.IProperties) class FakeProperties(Mock): pass FakeProperties.render = Mock(side_effect=lambda x: x) class FakeBuildStatus(Mock): pass r = FakeRequest() r.sources = [FakeSource()] r.sources[0].changes = [FakeChange()] r.sources[0].revision = "12345" self.master = fakemaster.make_master(wantData=True, testcase=self) self.worker = worker.FakeWorker(self.master) self.worker.attached(None) self.workerforbuilder = Mock(name='workerforbuilder') self.workerforbuilder.worker = self.worker self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder( fakemaster.make_master(wantData=True, testcase=self)) self.build.setBuilder(self.builder) self.properties = self.build.properties = FakeProperties() self.build_status = FakeBuildStatus() self.build._flushProperties = Mock() self.build.startBuild(self.build_status, self.workerforbuilder) def test_getProperty(self): self.build.getProperty('x') self.properties.getProperty.assert_called_with('x', None) def test_getProperty_default(self): self.build.getProperty('x', 'nox') self.properties.getProperty.assert_called_with('x', 'nox') def test_setProperty(self): self.build.setProperty('n', 'v', 's') self.properties.setProperty.assert_called_with('n', 'v', 's', runtime=True) def test_hasProperty(self): self.properties.hasProperty.return_value = True self.assertTrue(self.build.hasProperty('p')) self.properties.hasProperty.assert_called_with('p') def test_has_key(self): self.properties.has_key.return_value = True # getattr because pep8 doesn't like calls to has_key self.assertTrue(getattr(self.build, 'has_key')('p')) # has_key calls through to hasProperty self.properties.hasProperty.assert_called_with('p') def test_render(self): self.build.render("xyz") self.properties.render.assert_called_with("xyz") def test_getWorkerName_old_api(self): @implementer(interfaces.IProperties) class FakeProperties(Mock): pass import posixpath r = FakeRequest() build = Build([r]) build.properties = FakeProperties() build.builder = FakeBuilder(self.master) build.build_status = FakeBuildStatus() w = worker.FakeWorker(self.master) w.path_module = posixpath w.properties = FakeProperties() w.workername = 'worker name' w.worker_basedir = None workerforbuilder = Mock(name='workerforbuilder') workerforbuilder.worker = w build.workerforbuilder = workerforbuilder with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): new = build.getWorkerName() with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'getSlaveName' method is deprecated"): old = build.getSlaveName() self.assertEqual(old, 'worker name') self.assertIdentical(new, old) def test_workername_old_api(self): @implementer(interfaces.IProperties) class FakeProperties(Mock): pass import posixpath r = FakeRequest() build = Build([r]) build.properties = FakeProperties() build.builder = FakeBuilder(self.master) build.build_status = FakeBuildStatus() w = worker.FakeWorker(self.master) w.path_module = posixpath w.properties = FakeProperties() w.workername = 'worker name' w.worker_basedir = None workerforbuilder = Mock(name='workerforbuilder') workerforbuilder.worker = w build.setupWorkerForBuilder(workerforbuilder) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): new = build.workername with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavename' attribute is deprecated"): old = build.slavename self.assertEqual(old, 'worker name') self.assertIdentical(new, old)
class TestBuildProperties(TestReactorMixin, unittest.TestCase): """ Test that a Build has the necessary L{IProperties} methods, and that they properly delegate to the C{build_status} attribute - so really just a test of the L{IProperties} adapter. """ def setUp(self): self.setUpTestReactor() @implementer(interfaces.IProperties) class FakeProperties(Mock): pass FakeProperties.render = Mock(side_effect=lambda x: x) FakeProperties.asList = Mock(side_effect=lambda: []) class FakeBuildStatus(Mock): pass r = FakeRequest() r.sources = [FakeSource()] r.sources[0].changes = [FakeChange()] r.sources[0].revision = "12345" self.master = fakemaster.make_master(self, wantData=True) self.worker = worker.FakeWorker(self.master) self.worker.attached(None) self.workerforbuilder = Mock(name='workerforbuilder') self.workerforbuilder.worker = self.worker self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder(fakemaster.make_master(self, wantData=True)) self.build.setBuilder(self.builder) self.properties = self.build.properties = FakeProperties() self.build_status = FakeBuildStatus() self.build.startBuild(self.build_status, self.workerforbuilder) def test_getProperty(self): self.build.getProperty('x') self.properties.getProperty.assert_called_with('x', None) def test_getProperty_default(self): self.build.getProperty('x', 'nox') self.properties.getProperty.assert_called_with('x', 'nox') def test_setProperty(self): self.build.setProperty('n', 'v', 's') self.properties.setProperty.assert_called_with('n', 'v', 's', runtime=True) def test_hasProperty(self): self.properties.hasProperty.return_value = True self.assertTrue(self.build.hasProperty('p')) self.properties.hasProperty.assert_called_with('p') def test_has_key(self): self.properties.has_key.return_value = True # getattr because pep8 doesn't like calls to has_key self.assertTrue(getattr(self.build, 'has_key')('p')) # has_key calls through to hasProperty self.properties.hasProperty.assert_called_with('p') def test_render(self): self.build.render("xyz") self.properties.render.assert_called_with("xyz")
class TestBuildProperties(unittest.TestCase): """ Test that a Build has the necessary L{IProperties} methods, and that they properly delegate to the C{build_status} attribute - so really just a test of the L{IProperties} adapter. """ def setUp(self): @implementer(interfaces.IProperties) class FakeProperties(Mock): pass class FakeBuildStatus(Mock): pass r = FakeRequest() r.sources = [FakeSource()] r.sources[0].changes = [FakeChange()] r.sources[0].revision = "12345" self.master = fakemaster.make_master(wantData=True, testcase=self) self.worker = worker.FakeWorker(self.master) self.worker.attached(None) self.workerforbuilder = Mock(name='workerforbuilder') self.workerforbuilder.worker = self.worker self.build = Build([r]) self.build.setStepFactories([]) self.builder = FakeBuilder( fakemaster.make_master(wantData=True, testcase=self)) self.build.setBuilder(self.builder) self.properties = self.build.properties = FakeProperties() self.build_status = FakeBuildStatus() self.build._flushProperties = Mock() self.build.startBuild(self.build_status, self.workerforbuilder) def test_getProperty(self): self.build.getProperty('x') self.properties.getProperty.assert_called_with('x', None) def test_getProperty_default(self): self.build.getProperty('x', 'nox') self.properties.getProperty.assert_called_with('x', 'nox') def test_setProperty(self): self.build.setProperty('n', 'v', 's') self.properties.setProperty.assert_called_with('n', 'v', 's', runtime=True) def test_hasProperty(self): self.properties.hasProperty.return_value = True self.assertTrue(self.build.hasProperty('p')) self.properties.hasProperty.assert_called_with('p') def test_has_key(self): self.properties.has_key.return_value = True # getattr because pep8 doesn't like calls to has_key self.assertTrue(getattr(self.build, 'has_key')('p')) # has_key calls through to hasProperty self.properties.hasProperty.assert_called_with('p') def test_render(self): self.build.render("xyz") self.properties.render.assert_called_with("xyz") def test_getWorkerName_old_api(self): @implementer(interfaces.IProperties) class FakeProperties(Mock): pass import posixpath r = FakeRequest() build = Build([r]) build.properties = FakeProperties() build.builder = FakeBuilder(self.master) build.build_status = FakeBuildStatus() w = worker.FakeWorker(self.master) w.path_module = posixpath w.properties = FakeProperties() w.workername = 'worker name' w.worker_basedir = None workerforbuilder = Mock(name='workerforbuilder') workerforbuilder.worker = w build.workerforbuilder = workerforbuilder with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): new = build.getWorkerName() with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'getSlaveName' method is deprecated"): old = build.getSlaveName() self.assertEqual(old, 'worker name') self.assertIdentical(new, old) def test_workername_old_api(self): @implementer(interfaces.IProperties) class FakeProperties(Mock): pass import posixpath r = FakeRequest() build = Build([r]) build.properties = FakeProperties() build.builder = FakeBuilder(self.master) build.build_status = FakeBuildStatus() w = worker.FakeWorker(self.master) w.path_module = posixpath w.properties = FakeProperties() w.workername = 'worker name' w.worker_basedir = None workerforbuilder = Mock(name='workerforbuilder') workerforbuilder.worker = w build.setupWorkerForBuilder(workerforbuilder) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): new = build.workername with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavename' attribute is deprecated"): old = build.slavename self.assertEqual(old, 'worker name') self.assertIdentical(new, old)