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