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 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 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 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 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 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 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)
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 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 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 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 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 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
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(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
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(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)
