def test_api_import(self): with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): # Old API end point, no warning. from buildbot.plugins import buildslave as buildslave_ns # New API. from buildbot.plugins import worker as worker_ns # New API. self.assertTrue(worker_ns.Worker is buildbot.worker.Worker) with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"'buildbot\.plugins\.buildslave' plugins " "namespace is deprecated"): # Old API, with warning self.assertTrue( buildslave_ns.BuildSlave is buildbot.worker.Worker) # Access of newly named workers through old entry point is an error. with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"'buildbot\.plugins\.buildslave' plugins " "namespace is deprecated"): self.assertRaises(AttributeError, lambda: buildslave_ns.Worker) # Access of old-named workers through new API is an error. self.assertRaises(AttributeError, lambda: worker_ns.BuildSlave)
def test_attribute_setter(self): class C(WorkerAPICompatMixin): def __init__(self): self.workers = None self._registerOldWorkerAttr("workers", name="buildslaves") self.workernames = None self._registerOldWorkerAttr("workernames") with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): c = C() c.workers = [1, 2, 3] c.workernames = ["a", "b", "c"] self.assertEqual(c.workers, [1, 2, 3]) self.assertEqual(c.workernames, ["a", "b", "c"]) with assertProducesWarning(DeprecatedWorkerNameWarning): c.buildslaves = [1, 2, 3] self.assertEqual(c.workers, [1, 2, 3]) with assertProducesWarning(DeprecatedWorkerNameWarning): c.slavenames = ["a", "b", "c"] self.assertEqual(c.workernames, ["a", "b", "c"])
def test_init_workersrcs_old_api_warns(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavesrcs' keyword argument is deprecated"): step = transfer.MultipleFileUpload(slavesrcs=['srcfile'], masterdest='dstfile') self.assertEqual(step.workersrcs, ['srcfile'])
def test_BuildslavesConnectorComponent_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="BuildslavesConnectorComponent was deprecated" ): from buildbot.db.buildslaves import BuildslavesConnectorComponent self.assertIdentical(BuildslavesConnectorComponent, workers.WorkersConnectorComponent)
def test_init_workerdest_old_api_warns(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavedest' keyword argument is deprecated"): step = transfer.JSONPropertiesDownload(slavedest='dstfile') self.assertEqual(step.workerdest, 'dstfile')
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)
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_init_workerdest_old_api_warns(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavedest' keyword argument is deprecated" ): step = transfer.StringDownload("srcfile", slavedest="dstfile") self.assertEqual(step.workerdest, "dstfile")
def test_init_workersrc_old_api_warns(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavesrc' keyword argument is deprecated"): step = transfer.DirectoryUpload(slavesrc='srcfile', masterdest='dstfile') self.assertEqual(step.workersrc, 'srcfile')
def test_ILatentBuildSlave_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="ILatentBuildSlave was deprecated"): deprecated = interfaces.ILatentBuildSlave self.assertIdentical(deprecated, interfaces.ILatentWorker)
def test_new_api_thirdparty(self): # Third party plugins that use new API should work only through # new API. with assertProducesWarning(DeprecatedWorkerNameWarning, message_pattern="namespace is deprecated"): self.assertRaises(AttributeError, lambda: self.buildslave_ns.newthirdparty) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): self.assertTrue(self.worker_ns.newthirdparty is ClassWithInterface)
def test_new_api_thirdparty_deep(self): # TODO: Why it's not AttributeError (as in tests above), but # PluginDBError? with assertProducesWarning(DeprecatedWorkerNameWarning, message_pattern="namespace is deprecated"): self.assertRaises(PluginDBError, lambda: self.buildslave_ns.deep.newthirdparty) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): self.assertTrue(self.worker_ns.deep.newthirdparty is ClassWithInterface)
def test_ISlaveStatus_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="ISlaveStatus was deprecated"): deprecated = interfaces.ISlaveStatus self.assertIdentical(deprecated, interfaces.IWorkerStatus)
def test_RemoteShellCommand_usePTY(self): with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): cmd = remotecommand.RemoteShellCommand( 'workdir', 'command') self.assertTrue(cmd.args['usePTY'] is None) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): cmd = remotecommand.RemoteShellCommand( 'workdir', 'command', usePTY=True) self.assertTrue(cmd.args['usePTY']) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): cmd = remotecommand.RemoteShellCommand( 'workdir', 'command', usePTY=False) self.assertFalse(cmd.args['usePTY']) with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slave-config' value of 'usePTY' " "attribute is deprecated"): cmd = remotecommand.RemoteShellCommand( 'workdir', 'command', usePTY='slave-config') self.assertTrue(cmd.args['usePTY'] is None)
def test_old_api_access_produces_warning(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"'buildbot\.plugins\.buildslave' plugins " "namespace is deprecated", ): # Old API, with warning self.assertTrue(self.buildslave_ns.BuildSlave is ClassWithInterface)
def test_AbstractSlaveBuilder_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="AbstractSlaveBuilder was deprecated"): from buildbot.process.slavebuilder import AbstractSlaveBuilder self.assertIdentical(AbstractSlaveBuilder, AbstractWorkerForBuilder)
def test_enforceChosenSlave_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="enforceChosenSlave was deprecated"): deprecated = builder.enforceChosenSlave self.assertIdentical(deprecated, builder.enforceChosenWorker)
def test_SlaveBuildStep_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="SlaveBuildStep was deprecated"): from buildbot.steps.slave import SlaveBuildStep self.assertIdentical(SlaveBuildStep, worker.WorkerBuildStep)
def test_SlaveLock_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="SlaveLock was deprecated"): from buildbot.locks import SlaveLock self.assertIdentical(SlaveLock, WorkerLock)
def test_EC2LatentBuildSlave_deprecated(self): from buildbot.worker.ec2 import EC2LatentWorker with assertProducesWarning(DeprecatedWorkerNameWarning, message_pattern="EC2LatentBuildSlave was deprecated"): from buildbot.buildslave.ec2 import EC2LatentBuildSlave self.assertIdentical(EC2LatentBuildSlave, EC2LatentWorker)
def test_module_reload(self): Worker = type("Worker", (object,), {}) buildbot_module = new.module('buildbot_module') buildbot_module.Worker = Worker with mock.patch.dict(sys.modules, {'buildbot_module': buildbot_module}): scope = buildbot_module.__dict__ deprecatedWorkerModuleAttribute(scope, Worker) # Overwrite with Twisted's module wrapper. import buildbot_module # Module reload is effectively re-run of module contents. Worker = type("Worker", (object,), {}) buildbot_module.Worker = Worker scope = buildbot_module.__dict__ deprecatedWorkerModuleAttribute(scope, Worker) # Overwrite with Twisted's module wrapper. import buildbot_module with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): W = buildbot_module.Worker self.assertIdentical(W, Worker) with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"buildbot_module\.Slave was deprecated in " r"Buildbot 0.9.0: Use Worker instead."): S = buildbot_module.Slave self.assertIdentical(S, Worker)
def test_init_maxCountForWorker_old_api_warns(self): counts = {'w1': 10, 'w2': 20} with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'maxCountForSlave' keyword argument is deprecated"): lock = WorkerLock("name", maxCount=1, maxCountForSlave=counts) self.assertEqual(lock.maxCountForWorker, counts)
def test_OpenStackLatentBuildSlave_deprecated(self): from buildbot.worker.openstack import OpenStackLatentWorker with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="OpenStackLatentBuildSlave was deprecated"): from buildbot.buildslave.openstack import OpenStackLatentBuildSlave self.assertIdentical(OpenStackLatentBuildSlave, OpenStackLatentWorker)
def test_BuildSlave_deprecated_worker(self): from buildbot.worker import Worker import buildbot.buildslave as bs with assertProducesWarning(DeprecatedWorkerNameWarning, message_pattern="BuildSlave was deprecated"): deprecated = bs.BuildSlave self.assertIdentical(deprecated, Worker)
def test_BuildslaveChoiceParameter_deprecated(self): from buildbot.schedulers.forcesched import WorkerChoiceParameter with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="BuildslaveChoiceParameter was deprecated"): from buildbot.schedulers.forcesched import BuildslaveChoiceParameter self.assertIdentical(BuildslaveChoiceParameter, WorkerChoiceParameter)
def test_old_api_thirdparty_deep(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"'buildbot\.plugins\.buildslave' plugins " "namespace is deprecated", ): self.assertTrue(self.buildslave_ns.deep.thirdparty is ClassWithInterface) with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): self.assertTrue(self.worker_ns.deep.thirdparty is ClassWithInterface)
def test_BuildSlaveTooOldError_deprecated(self): from buildbot.interfaces import WorkerTooOldError with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="BuildSlaveTooOldError was deprecated"): from buildbot.interfaces import BuildSlaveTooOldError self.assertIdentical(BuildSlaveTooOldError, WorkerTooOldError)
def test_LibVirtSlave_deprecated(self): from buildbot.worker.libvirt import LibVirtWorker with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="LibVirtSlave was deprecated"): from buildbot.buildslave.libvirt import LibVirtSlave self.assertIdentical(LibVirtSlave, LibVirtWorker)
def test_expectations_deprecated(self): self.successResultOf(self.makeBuilder()) with assertProducesWarning( Warning, message_pattern="'Builder.expectations' is deprecated."): deprecated = self.bldr.expectations self.assertIdentical(deprecated, None)
def test_SlaveBuilder_deprecated(self): from buildbot.process.workerforbuilder import WorkerForBuilder with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="SlaveBuilder was deprecated"): from buildbot.process.slavebuilder import SlaveBuilder self.assertIdentical(SlaveBuilder, WorkerForBuilder)
def test_canStartWithWorkerForBuilder_old_api(self): bldr = builder.Builder('bldr') bldr.config = mock.Mock() bldr.config.locks = [] with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'canStartWithSlavebuilder' method is deprecated"): with mock.patch( 'buildbot.process.build.Build.canStartWithWorkerForBuilder', mock.Mock(return_value='dummy')): dummy = yield bldr.canStartWithSlavebuilder(mock.Mock(), mock.Mock()) self.assertEqual(dummy, 'dummy')
def test_getAvailableWorkers_old_api(self): bldr = builder.Builder('bldr', _addServices=False) with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'getAvailableSlaves' method is deprecated"): method = mock.Mock(return_value='dummy') with mock.patch( 'buildbot.process.builder.Builder.getAvailableWorkers', method): dummy = bldr.getAvailableSlaves(mock.Mock()) self.assertEqual(dummy, 'dummy') self.assertTrue(method.called)
def test_workerVersionIsOlderThan_old_api(self): bs = buildstep.BuildStep() bs.build = mock.Mock() bs.build.getWorkerCommandVersion = mock.Mock() bs.build.getWorkerCommandVersion.return_value = "1.0" with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slaveVersionIsOlderThan' method is deprecated" ): older = bs.slaveVersionIsOlderThan(None, "2.0") self.assertTrue(older) with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slaveVersionIsOlderThan' method is deprecated" ): older = bs.slaveVersionIsOlderThan(None, "0.5") self.assertFalse(older)
def test_slavename_deprecated(self): bs = yield self.createWorker('bot', 'pass') yield bs.startService() with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavename' property is deprecated"): old_name = bs.slavename with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): name = bs.workername self.assertEqual(name, old_name)
def test_worker_version_old_api(self): bs = buildstep.BuildStep() bs.build = mock.Mock() bs.build.getWorkerCommandVersion = mock.Mock() bs.build.getWorkerCommandVersion.return_value = "ver" with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slaveVersion' method is deprecated"): ver = bs.slaveVersion(None) self.assertEqual(ver, "ver")
def test_getWorkerName_old_api(self): bs = buildstep.BuildStep() bs.build = mock.Mock() bs.build.getWorkerName = mock.Mock() bs.build.getWorkerName.return_value = "worker name" with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'getSlaveName' method is deprecated"): name = bs.getSlaveName() self.assertEqual(name, "worker name")
def test_getFileContentFromWorker_old_api(self): method = mock.Mock(return_value='dummy') with mock.patch( 'buildbot.steps.worker.CompositeStepMixin.getFileContentFromWorker', method): m = worker.CompositeStepMixin() with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern= "'getFileContentFromSlave' method is deprecated"): dummy = m.getFileContentFromSlave('file') self.assertEqual(dummy, 'dummy') method.assert_called_once_with('file')
def test_workersrcs_old_api(self): step = transfer.MultipleFileUpload( workersrcs=['srcfile'], masterdest='dstfile') with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): new = step.workersrcs with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavesrcs' attribute is deprecated"): old = step.slavesrcs self.assertIdentical(new, old)
def test_basic(self): self.patch(config, "_in_unit_tests", False) with assertProducesWarning( ConfigWarning, message_pattern=r"`buildbotNetUsageData` is not configured and defaults to basic."): master = self.getMaster(self.getBaseConfig()) data = computeUsageData(master) self.assertEqual(sorted(data.keys()), sorted(['versions', 'db', 'platform', 'installid', 'mq', 'plugins', 'www_plugins'])) self.assertEqual(data['plugins']['buildbot/worker/base/Worker'], 3) self.assertEqual(sorted(data['plugins'].keys()), sorted( ['buildbot/schedulers/forcesched/ForceScheduler', 'buildbot/worker/base/Worker', 'buildbot/steps/shell/ShellCommand', 'buildbot/config/BuilderConfig']))
def test_plugins_util_BuildslaveChoiceParameter_import(self): from buildbot.plugins import util with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): new = util.WorkerChoiceParameter with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=re.escape( "'buildbot.util.BuildslaveChoiceParameter' is deprecated, " "use 'buildbot.util.WorkerChoiceParameter' instead")): deprecated = util.BuildslaveChoiceParameter self.assertIdentical(new, deprecated)
def test_method_wrapper(self): class C(object): def updateWorker(self, res): return res deprecatedWorkerClassMethod(locals(), updateWorker) c = C() with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): self.assertEqual(c.updateWorker("test"), "test") with assertProducesWarning(DeprecatedWorkerNameWarning): self.assertEqual(c.updateSlave("test"), "test")
def test_canStartWithWorkerForBuilder_no_buildrequests(self): bldr = builder.Builder('bldr') bldr.config = mock.Mock() bldr.config.locks = [] with assertProducesWarning( Warning, message_pattern=( "Not passing corresponding buildrequests to " "Builder.canStartWithWorkerForBuilder is deprecated")): with mock.patch( 'buildbot.process.build.Build.canStartWithWorkerForBuilder', mock.Mock(return_value='dummy')): dummy = yield bldr.canStartWithWorkerForBuilder(mock.Mock()) self.assertEqual(dummy, 'dummy')
def test_worker_old_api(self): cmd = remotecommand.RemoteCommand('cmd', []) w = mock.Mock() with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): self.assertIdentical(cmd.worker, None) cmd.worker = w with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'buildslave' attribute is deprecated"): old = cmd.buildslave self.assertIdentical(old, w)
def do_secret_test(self, secret_specifier, expected_obfuscation, expected_value): with assertProducesWarning(DeprecatedApiWarning): yield self.setupConfig( masterConfig(secret_specifier=secret_specifier)) build = yield self.doForceBuild(wantSteps=True, wantLogs=True) self.assertEqual(build['buildid'], 1) patterns = [ "echo {}".format(expected_obfuscation), base64.b64encode( (expected_value + "\n").encode('utf-8')).decode('utf-8'), ] res = yield self.checkBuildStepLogExist(build, patterns) self.assertTrue(res)
def test_worker_old_api(self): bs = buildstep.BuildStep() worker = mock.Mock() with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): bs.setWorker(worker) new = bs.worker with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'buildslave' attribute is deprecated"): old = bs.buildslave self.assertIdentical(new, worker) self.assertIdentical(old, new)
def test_produces_warning(self): class C(object): @property def workername(self): return "name" deprecatedWorkerClassProperty(locals(), workername) c = C() with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): self.assertEqual(c.workername, "name") with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="'slavename' property is deprecated, " "use 'workername' instead"): self.assertEqual(c.slavename, "name")
def do_test_nextWorker(self, nextWorker, exp_choice=None, exp_warning=False): def makeBuilderConfig(): return config.BuilderConfig(name='bldrconf', workernames=['wk1', 'wk2'], builddir='bdir', factory=factory.BuildFactory(), nextWorker=nextWorker) if exp_warning: with assertProducesWarning( config.ConfigWarning, message_pattern=r"nextWorker now takes a 3rd argument"): builder_config = makeBuilderConfig() else: builder_config = makeBuilderConfig() self.bldr = yield self.createBuilder('B', builderid=78, builder_config=builder_config) for i in range(4): self.addWorkers({'test-worker%d' % i: 1}) rows = [ fakedb.SourceStamp(id=21), fakedb.Builder(id=78, name='B'), fakedb.Buildset(id=12, reason='because'), fakedb.BuildsetSourceStamp(sourcestampid=21, buildsetid=12), fakedb.BuildRequest(id=12, buildsetid=12, builderid=78), ] if exp_choice is None: exp_claims = [] exp_builds = [] else: exp_claims = [12] exp_builds = [('test-worker%d' % exp_choice, [12])] yield self.do_test_maybeStartBuildsOnBuilder(rows=rows, exp_claims=exp_claims, exp_builds=exp_builds)
def test_explicit_new_name(self): BuildSlave = type("BuildSlave", (object,), {}) buildbot_module = new.module('buildbot_module') buildbot_module.BuildSlave = BuildSlave with mock.patch.dict(sys.modules, {'buildbot_module': buildbot_module}): scope = buildbot_module.__dict__ deprecatedWorkerModuleAttribute( scope, BuildSlave, compat_name="BuildSlave", new_name="Worker") # Overwrite with Twisted's module wrapper. import buildbot_module with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"buildbot_module\.BuildSlave was deprecated in " r"Buildbot 0.9.0: Use Worker instead."): S = buildbot_module.BuildSlave self.assertIdentical(S, BuildSlave)
def test_produces_warning(self): Worker = type("Worker", (object,), {}) buildbot_module = new.module('buildbot_module') buildbot_module.Worker = Worker with mock.patch.dict(sys.modules, {'buildbot_module': buildbot_module}): scope = buildbot_module.__dict__ deprecatedWorkerModuleAttribute(scope, Worker) # Overwrite with Twisted's module wrapper. import buildbot_module with assertNotProducesWarnings(DeprecatedWorkerAPIWarning): W = buildbot_module.Worker self.assertIdentical(W, Worker) with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern=r"buildbot_module\.Slave was deprecated in " r"Buildbot 0.9.0: Use Worker instead."): S = buildbot_module.Slave self.assertIdentical(S, Worker)
def test_NoSlaveError_deprecated(self): with assertProducesWarning( DeprecatedWorkerNameWarning, message_pattern="NoSlaveError was deprecated"): interfaces.NoSlaveError
"try 'pip install mock'") if LooseVersion(mock.__version__) < LooseVersion("0.8"): raise ImportError("\nBuildbot tests require mock version 0.8.0 or " "higher; try 'pip install -U mock'") # Force loading of deprecated modules and check that appropriate warnings # were emitted. # Without explicit load of deprecated modules it's hard to predict when # they will be imported and when warning should be caught. from buildbot.test.util.warnings import assertProducesWarning # noqa pylint: disable=wrong-import-position from buildbot.worker_transition import DeprecatedWorkerAPIWarning # noqa pylint: disable=wrong-import-position from buildbot.worker_transition import DeprecatedWorkerModuleWarning # noqa pylint: disable=wrong-import-position with assertProducesWarning( DeprecatedWorkerModuleWarning, message_pattern=r"'buildbot\.buildslave' module is deprecated"): import buildbot.buildslave as _ # noqa with assertProducesWarning( DeprecatedWorkerModuleWarning, message_pattern=r"'buildbot\.steps\.slave' module is deprecated"): import buildbot.steps.slave as _ # noqa with assertProducesWarning( DeprecatedWorkerModuleWarning, message_pattern= r"'buildbot\.process\.slavebuilder' module is deprecated"): import buildbot.process.slavebuilder as _ # noqa with assertProducesWarning(
def test_build_subject_deprecated(self): with assertProducesWarning(DeprecatedApiWarning, "subject parameter"): yield self.setup_generator(subject='subject')
def test_want_steps_deprecated(self): with assertProducesWarning(DeprecatedApiWarning, "wantSteps has been deprecated"): formatter = message.MessageFormatter(wantSteps=True) self.assertEqual(formatter.want_steps, True)
def test_want_logs_deprecated(self): with assertProducesWarning(DeprecatedApiWarning, "wantLogs has been deprecated"): formatter = message.MessageFormatter(wantLogs=True) self.assertEqual(formatter.want_logs, True) self.assertEqual(formatter.want_logs_content, True)
def test_warnigs_catched(self): # Assertion is correct. with assertProducesWarning(SomeWarning): warnings.warn("test", SomeWarning)
def test_warnigs_catched_pattern_check(self): # Assertion is correct. with assertProducesWarning(SomeWarning, message_pattern=r"t.st"): warnings.warn("The test", SomeWarning)
def f(): # Assertion fails. with assertProducesWarning(SomeWarning, message_pattern=r"other"): warnings.warn("The test", SomeWarning)
with assertProducesWarnings( DeprecatedApiWarning, messages_patterns=[ r" buildbot\.status\.build has been deprecated", r" buildbot\.status\.buildrequest has been deprecated", r" buildbot\.status\.event has been deprecated", r" buildbot\.status\.worker has been deprecated", r" buildbot\.status\.buildset has been deprecated", r" buildbot\.status\.master has been deprecated", r" buildbot\.status\.base has been deprecated", ]): import buildbot.status.base as _ # noqa with assertProducesWarning( DeprecatedApiWarning, message_pattern=r" buildbot\.status\.worker has been deprecated"): import buildbot.status.worker as _ # noqa # All deprecated modules should be loaded, consider future warnings in tests as errors. # In order to not pollute the test outputs, # warnings in tests shall be forcefully tested with assertProducesWarning, # or shutdown using the warning module warnings.filterwarnings('error') # if buildbot_worker is installed in pip install -e mode, then the docker directory will # match "import docker", and produce a warning. # We just suppress this warning instead of doing silly workaround. warnings.filterwarnings( 'ignore', "Not importing directory.*docker': missing __init__.py", category=ImportWarning)
def test_new_api_through_old_namespace(self): # Access of newly named workers through old entry point is an error. with assertProducesWarning(DeprecatedWorkerNameWarning, message_pattern="namespace is deprecated"): self.assertRaises(AttributeError, lambda: self.buildslave_ns.Worker)
def test_SlaveLock_deprecated(self): with assertProducesWarning(DeprecatedWorkerNameWarning, message_pattern="SlaveLock was deprecated"): from buildbot.locks import SlaveLock self.assertIdentical(SlaveLock, WorkerLock)