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'])
Example #4
0
    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')
Example #6
0
    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)
Example #7
0
    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')
Example #10
0
    def test_ILatentBuildSlave_deprecated(self):
        with assertProducesWarning(
                DeprecatedWorkerNameWarning,
                message_pattern="ILatentBuildSlave was deprecated"):
            deprecated = interfaces.ILatentBuildSlave

        self.assertIdentical(deprecated, interfaces.ILatentWorker)
Example #11
0
 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)
Example #12
0
 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)
Example #13
0
    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)
Example #15
0
 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)
Example #17
0
    def test_enforceChosenSlave_deprecated(self):
        with assertProducesWarning(
                DeprecatedWorkerNameWarning,
                message_pattern="enforceChosenSlave was deprecated"):
            deprecated = builder.enforceChosenSlave

        self.assertIdentical(deprecated, builder.enforceChosenWorker)
Example #18
0
    def test_SlaveBuildStep_deprecated(self):
        with assertProducesWarning(
                DeprecatedWorkerNameWarning,
                message_pattern="SlaveBuildStep was deprecated"):
            from buildbot.steps.slave import SlaveBuildStep

        self.assertIdentical(SlaveBuildStep, worker.WorkerBuildStep)
Example #19
0
    def test_SlaveLock_deprecated(self):
        with assertProducesWarning(
                DeprecatedWorkerNameWarning,
                message_pattern="SlaveLock was deprecated"):
            from buildbot.locks import SlaveLock

        self.assertIdentical(SlaveLock, WorkerLock)
Example #20
0
    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)
Example #22
0
    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)
Example #24
0
    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)
Example #26
0
    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)
Example #27
0
    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)
Example #28
0
    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)
Example #29
0
    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')
Example #32
0
    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)
Example #33
0
    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)
Example #34
0
    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)
Example #35
0
    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")
Example #36
0
    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")
Example #37
0
 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')
Example #38
0
    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')
Example #43
0
    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")
Example #47
0
    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)
Example #50
0
 def test_NoSlaveError_deprecated(self):
     with assertProducesWarning(
             DeprecatedWorkerNameWarning,
             message_pattern="NoSlaveError was deprecated"):
         interfaces.NoSlaveError
Example #51
0
                      "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(
Example #52
0
 def test_build_subject_deprecated(self):
     with assertProducesWarning(DeprecatedApiWarning, "subject parameter"):
         yield self.setup_generator(subject='subject')
Example #53
0
 def test_want_steps_deprecated(self):
     with assertProducesWarning(DeprecatedApiWarning,
                                "wantSteps has been deprecated"):
         formatter = message.MessageFormatter(wantSteps=True)
     self.assertEqual(formatter.want_steps, True)
Example #54
0
 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)
Example #55
0
 def test_warnigs_catched(self):
     # Assertion is correct.
     with assertProducesWarning(SomeWarning):
         warnings.warn("test", SomeWarning)
Example #56
0
 def test_warnigs_catched_pattern_check(self):
     # Assertion is correct.
     with assertProducesWarning(SomeWarning, message_pattern=r"t.st"):
         warnings.warn("The test", SomeWarning)
Example #57
0
 def f():
     # Assertion fails.
     with assertProducesWarning(SomeWarning, message_pattern=r"other"):
         warnings.warn("The test", SomeWarning)
Example #58
0
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)
Example #59
0
 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)
Example #60
0
    def test_SlaveLock_deprecated(self):
        with assertProducesWarning(DeprecatedWorkerNameWarning,
                                   message_pattern="SlaveLock was deprecated"):
            from buildbot.locks import SlaveLock

        self.assertIdentical(SlaveLock, WorkerLock)