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, '')
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")
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)
