Python BotMaster.startService方法代码示例

# 需要导入模块: from buildbot.process.botmaster import BotMaster [as 别名]
# 或者: from buildbot.process.botmaster.BotMaster import startService [as 别名]
class TestCleanShutdown(unittest.TestCase):

    def setUp(self):
        self.botmaster = BotMaster(mock.Mock())
        self.reactor = mock.Mock()
        self.botmaster.startService()

    def assertReactorStopped(self, _=None):
        self.assertTrue(self.reactor.stop.called)

    def assertReactorNotStopped(self, _=None):
        self.assertFalse(self.reactor.stop.called)

    def makeFakeBuild(self):
        self.fake_builder = builder = mock.Mock()
        build = mock.Mock()
        builder.builder_status.getCurrentBuilds.return_value = [build]

        self.build_deferred = defer.Deferred()
        build.waitUntilFinished.return_value = self.build_deferred

        self.botmaster.builders = mock.Mock()
        self.botmaster.builders.values.return_value = [builder]

    def finishFakeBuild(self):
        self.fake_builder.builder_status.getCurrentBuilds.return_value = []
        self.build_deferred.callback(None)

    # tests

    def test_shutdown_idle(self):
        """Test that the master shuts down when it's idle"""
        self.botmaster.cleanShutdown(_reactor=self.reactor)
        self.assertReactorStopped()

    def test_shutdown_busy(self):
        """Test that the master shuts down after builds finish"""
        self.makeFakeBuild()

        self.botmaster.cleanShutdown(_reactor=self.reactor)

        # check that we haven't stopped yet, since there's a running build
        self.assertReactorNotStopped()

        # try to shut it down again, just to check that this does not fail
        self.botmaster.cleanShutdown(_reactor=self.reactor)

        # Now we cause the build to finish
        self.finishFakeBuild()

        # And now we should be stopped
        self.assertReactorStopped()

    def test_shutdown_cancel_not_shutting_down(self):
        """Test that calling cancelCleanShutdown when none is in progress
        works"""
        # this just shouldn't fail..
        self.botmaster.cancelCleanShutdown()

    def test_shutdown_cancel(self):
        """Test that we can cancel a shutdown"""
        self.makeFakeBuild()

        self.botmaster.cleanShutdown(_reactor=self.reactor)

        # Next we check that we haven't stopped yet, since there's a running
        # build.
        self.assertReactorNotStopped()

        # but the BuildRequestDistributor should not be running
        self.assertFalse(self.botmaster.brd.running)

        # Cancel the shutdown
        self.botmaster.cancelCleanShutdown()

        # Now we cause the build to finish
        self.finishFakeBuild()

        # We should still be running!
        self.assertReactorNotStopped()

        # and the BuildRequestDistributor should be, as well
        self.assertTrue(self.botmaster.brd.running)

# 需要导入模块: from buildbot.process.botmaster import BotMaster [as 别名]
# 或者: from buildbot.process.botmaster.BotMaster import startService [as 别名]
class TestBotMaster(unittest.TestCase):

    def setUp(self):
        self.master = fakemaster.make_master(testcase=self, wantMq=True,
                                             wantData=True)
        self.master.mq = self.master.mq
        self.botmaster = BotMaster(self.master)
        self.new_config = mock.Mock()
        self.botmaster.startService()

    def tearDown(self):
        return self.botmaster.stopService()

    def test_reconfigService(self):
        # check that reconfigServiceBuilders is called.
        self.patch(self.botmaster, 'reconfigServiceBuilders',
                   mock.Mock(side_effect=lambda c: defer.succeed(None)))
        self.patch(self.botmaster, 'maybeStartBuildsForAllBuilders',
                   mock.Mock())

        new_config = mock.Mock()
        d = self.botmaster.reconfigService(new_config)

        @d.addCallback
        def check(_):
            self.botmaster.reconfigServiceBuilders.assert_called_with(
                new_config)
            self.assertTrue(
                self.botmaster.maybeStartBuildsForAllBuilders.called)
        return d

    @defer.inlineCallbacks
    def test_reconfigServiceBuilders_add_remove(self):
        bc = config.BuilderConfig(name='bldr', factory=factory.BuildFactory(),
                                  slavename='f')
        self.new_config.builders = [bc]

        yield self.botmaster.reconfigServiceBuilders(self.new_config)

        bldr = self.botmaster.builders['bldr']
        self.assertIdentical(bldr.parent, self.botmaster)
        self.assertIdentical(bldr.master, self.master)
        self.assertEqual(self.botmaster.builderNames, ['bldr'])

        self.new_config.builders = []

        yield self.botmaster.reconfigServiceBuilders(self.new_config)

        self.assertIdentical(bldr.parent, None)
        self.assertIdentical(bldr.master, None)
        self.assertEqual(self.botmaster.builders, {})
        self.assertEqual(self.botmaster.builderNames, [])

    def test_maybeStartBuildsForBuilder(self):
        brd = self.botmaster.brd = mock.Mock()

        self.botmaster.maybeStartBuildsForBuilder('frank')

        brd.maybeStartBuildsOn.assert_called_once_with(['frank'])

    def test_maybeStartBuildsForSlave(self):
        brd = self.botmaster.brd = mock.Mock()
        b1 = mock.Mock(name='frank')
        b1.name = 'frank'
        b2 = mock.Mock(name='larry')
        b2.name = 'larry'
        self.botmaster.getBuildersForSlave = mock.Mock(return_value=[b1, b2])

        self.botmaster.maybeStartBuildsForSlave('centos')

        self.botmaster.getBuildersForSlave.assert_called_once_with('centos')
        brd.maybeStartBuildsOn.assert_called_once_with(['frank', 'larry'])

    def test_maybeStartBuildsForAll(self):
        brd = self.botmaster.brd = mock.Mock()
        self.botmaster.builderNames = ['frank', 'larry']

        self.botmaster.maybeStartBuildsForAllBuilders()

        brd.maybeStartBuildsOn.assert_called_once_with(['frank', 'larry'])

# 需要导入模块: from buildbot.process.botmaster import BotMaster [as 别名]
# 或者: from buildbot.process.botmaster.BotMaster import startService [as 别名]
class TestBotMaster(unittest.TestCase):
    def setUp(self):
        self.master = fakemaster.make_master()
        self.botmaster = BotMaster(self.master)
        self.new_config = mock.Mock()
        self.botmaster.startService()

    def tearDown(self):
        return self.botmaster.stopService()

    def test_reconfigService(self):
        # check that reconfigServiceSlaves and reconfigServiceBuilders are
        # both called; they will be tested invidually below
        self.patch(self.botmaster, "reconfigServiceBuilders", mock.Mock(side_effect=lambda c: defer.succeed(None)))
        self.patch(self.botmaster, "reconfigServiceSlaves", mock.Mock(side_effect=lambda c: defer.succeed(None)))
        self.patch(self.botmaster, "maybeStartBuildsForAllBuilders", mock.Mock())

        old_config, new_config = mock.Mock(), mock.Mock()
        d = self.botmaster.reconfigService(new_config)

        @d.addCallback
        def check(_):
            self.botmaster.reconfigServiceBuilders.assert_called_with(new_config)
            self.botmaster.reconfigServiceSlaves.assert_called_with(new_config)
            self.assertTrue(self.botmaster.maybeStartBuildsForAllBuilders.called)

        return d

    @defer.deferredGenerator
    def test_reconfigServiceSlaves_add_remove(self):
        sl = FakeBuildSlave("sl1")
        self.new_config.slaves = [sl]

        wfd = defer.waitForDeferred(self.botmaster.reconfigServiceSlaves(self.new_config))
        yield wfd
        wfd.getResult()

        self.assertIdentical(sl.parent, self.botmaster)
        self.assertEqual(self.botmaster.slaves, {"sl1": sl})

        self.new_config.slaves = []

        wfd = defer.waitForDeferred(self.botmaster.reconfigServiceSlaves(self.new_config))
        yield wfd
        wfd.getResult()

        self.assertIdentical(sl.parent, None)
        self.assertIdentical(sl.master, None)

    @defer.deferredGenerator
    def test_reconfigServiceSlaves_reconfig(self):
        sl = FakeBuildSlave("sl1")
        self.botmaster.slaves = dict(sl1=sl)
        sl.setServiceParent(self.botmaster)
        sl.master = self.master
        sl.botmaster = self.botmaster

        sl_new = FakeBuildSlave("sl1")
        self.new_config.slaves = [sl_new]

        wfd = defer.waitForDeferred(self.botmaster.reconfigServiceSlaves(self.new_config))
        yield wfd
        wfd.getResult()

        # sl was not replaced..
        self.assertIdentical(self.botmaster.slaves["sl1"], sl)

    @defer.deferredGenerator
    def test_reconfigServiceSlaves_class_changes(self):
        sl = FakeBuildSlave("sl1")
        self.botmaster.slaves = dict(sl1=sl)
        sl.setServiceParent(self.botmaster)
        sl.master = self.master
        sl.botmaster = self.botmaster

        sl_new = FakeBuildSlave2("sl1")
        self.new_config.slaves = [sl_new]

        wfd = defer.waitForDeferred(self.botmaster.reconfigServiceSlaves(self.new_config))
        yield wfd
        wfd.getResult()

        # sl *was* replaced (different class)
        self.assertIdentical(self.botmaster.slaves["sl1"], sl_new)

    @defer.deferredGenerator
    def test_reconfigServiceBuilders_add_remove(self):
        bc = config.BuilderConfig(name="bldr", factory=mock.Mock(), slavename="f")
        self.new_config.builders = [bc]

        wfd = defer.waitForDeferred(self.botmaster.reconfigServiceBuilders(self.new_config))
        yield wfd
        wfd.getResult()

        bldr = self.botmaster.builders["bldr"]
        self.assertIdentical(bldr.parent, self.botmaster)
        self.assertIdentical(bldr.master, self.master)
        self.assertEqual(self.botmaster.builderNames, ["bldr"])

        self.new_config.builders = []
#.........这里部分代码省略.........

# 需要导入模块: from buildbot.process.botmaster import BotMaster [as 别名]
# 或者: from buildbot.process.botmaster.BotMaster import startService [as 别名]
class TestBotMaster(unittest.TestCase):

    def setUp(self):
        self.master = fakemaster.make_master()
        self.botmaster = BotMaster(self.master)
        self.new_config = mock.Mock()
        self.botmaster.startService()

    def tearDown(self):
        return self.botmaster.stopService()

    def test_reconfigService(self):
        # check that reconfigServiceSlaves and reconfigServiceBuilders are
        # both called; they will be tested invidually below
        self.patch(self.botmaster, 'reconfigServiceBuilders',
                mock.Mock(side_effect=lambda c : defer.succeed(None)))
        self.patch(self.botmaster, 'reconfigServiceSlaves',
                mock.Mock(side_effect=lambda c : defer.succeed(None)))
        self.patch(self.botmaster, 'maybeStartBuildsForAllBuilders',
                mock.Mock())

        old_config, new_config = mock.Mock(), mock.Mock()
        d = self.botmaster.reconfigService(new_config)
        @d.addCallback
        def check(_):
            self.botmaster.reconfigServiceBuilders.assert_called_with(
                    new_config)
            self.botmaster.reconfigServiceSlaves.assert_called_with(
                    new_config)
            self.assertTrue(
                    self.botmaster.maybeStartBuildsForAllBuilders.called)
        return d

    @defer.inlineCallbacks
    def test_reconfigServiceSlaves_add_remove(self):
        sl = FakeBuildSlave('sl1')
        self.new_config.slaves = [ sl ]

        yield self.botmaster.reconfigServiceSlaves(self.new_config)

        self.assertIdentical(sl.parent, self.botmaster)
        self.assertEqual(self.botmaster.slaves, { 'sl1' : sl })

        self.new_config.slaves = [ ]

        yield self.botmaster.reconfigServiceSlaves(self.new_config)

        self.assertIdentical(sl.parent, None)
        self.assertIdentical(sl.master, None)

    @defer.inlineCallbacks
    def test_reconfigServiceSlaves_reconfig(self):
        sl = FakeBuildSlave('sl1')
        self.botmaster.slaves = dict(sl1=sl)
        sl.setServiceParent(self.botmaster)
        sl.master = self.master
        sl.botmaster = self.botmaster

        sl_new = FakeBuildSlave('sl1')
        self.new_config.slaves = [ sl_new ]

        yield self.botmaster.reconfigServiceSlaves(self.new_config)

        # sl was not replaced..
        self.assertIdentical(self.botmaster.slaves['sl1'], sl)

    @defer.inlineCallbacks
    def test_reconfigServiceSlaves_class_changes(self):
        sl = FakeBuildSlave('sl1')
        self.botmaster.slaves = dict(sl1=sl)
        sl.setServiceParent(self.botmaster)
        sl.master = self.master
        sl.botmaster = self.botmaster

        sl_new = FakeBuildSlave2('sl1')
        self.new_config.slaves = [ sl_new ]

        yield self.botmaster.reconfigServiceSlaves(self.new_config)

        # sl *was* replaced (different class)
        self.assertIdentical(self.botmaster.slaves['sl1'], sl_new)

    @defer.inlineCallbacks
    def test_reconfigServiceBuilders_add_remove(self):
        bc = config.BuilderConfig(name='bldr', factory=mock.Mock(),
                            slavename='f')
        self.new_config.builders = [ bc ]

        yield self.botmaster.reconfigServiceBuilders(self.new_config)

        bldr = self.botmaster.builders['bldr']
        self.assertIdentical(bldr.parent, self.botmaster)
        self.assertIdentical(bldr.master, self.master)
        self.assertEqual(self.botmaster.builderNames, [ 'bldr' ])

        self.new_config.builders = [ ]

        yield self.botmaster.reconfigServiceBuilders(self.new_config)

        self.assertIdentical(bldr.parent, None)
#.........这里部分代码省略.........

# 需要导入模块: from buildbot.process.botmaster import BotMaster [as 别名]
# 或者: from buildbot.process.botmaster.BotMaster import startService [as 别名]
class TestCleanShutdown(unittest.TestCase):
    def setUp(self):
        self.master = BotMaster(Mock())
        self.master.reactor = Mock()
        self.master.startService()

    def test_shutdown_idle(self):
        """Test that the master shuts down when it's idle"""
        d = self.master.cleanShutdown()
        def _check(ign):
            self.assertEquals(self.master.reactor.stop.called, True)

        d.addCallback(_check)
        return d

    def test_shutdown_busy(self):
        """Test that the master shuts down after builds finish"""
        # Fake some builds
        builder = Mock()
        build = Mock()
        builder.builder_status.getCurrentBuilds.return_value = [build]

        d_finished = defer.Deferred()
        build.waitUntilFinished.return_value = d_finished

        self.master.builders = Mock()
        self.master.builders.values.return_value = [builder]

        d_shutdown = self.master.cleanShutdown()

        # Trigger the loop to get things going
        self.master.loop.trigger()

        # First we wait for it to quiet down again
        d = self.master.loop.when_quiet()

        # Next we check that we haven't stopped yet, since there's a running
        # build
        def _check1(ign):
            self.assertEquals(self.master.reactor.stop.called, False)
        d.addCallback(_check1)

        # Now we cause the build to finish, then kick the loop again,
        # empty out the list of running builds, and wait for the shutdown
        # process to finish
        def _finish_build(ign):
            d_finished.callback(None)
            self.master.loop.trigger()
            self.master.builders.values.return_value = []
            return d_shutdown
        d.addCallback(_finish_build)

        # And now we should be done
        def _check2(ign):
            self.assertEquals(self.master.reactor.stop.called, True)
        d.addCallback(_check2)

        return d

    def test_shutdown_cancel(self):
        """Test that we can cancel a shutdown"""
        # Fake some builds
        builder = Mock()
        build = Mock()
        builder.builder_status.getCurrentBuilds.return_value = [build]

        d_finished = defer.Deferred()
        build.waitUntilFinished.return_value = d_finished

        self.master.builders = Mock()
        self.master.builders.values.return_value = [builder]

        d_shutdown = self.master.cleanShutdown()

        # Trigger the loop to get things going
        self.master.loop.trigger()

        # First we wait for it to quiet down again
        d = self.master.loop.when_quiet()

        # Next we check that we haven't stopped yet, since there's a running
        # build.
        # We cancel the shutdown here too
        def _check1(ign):
            self.assertEquals(self.master.reactor.stop.called, False)
            self.master.cancelCleanShutdown()
        d.addCallback(_check1)

        # Now we cause the build to finish, then kick the loop again,
        # empty out the list of running builds, and wait for the shutdown
        # process to finish
        def _finish_build(ign):
            d_finished.callback(None)
            self.master.loop.trigger()
            self.master.builders.values.return_value = []
            return d_shutdown
        d.addCallback(_finish_build)

        # We should still be running!
        def _check2(ign):
#.........这里部分代码省略.........

# 需要导入模块: from buildbot.process.botmaster import BotMaster [as 别名]
# 或者: from buildbot.process.botmaster.BotMaster import startService [as 别名]
class TestCleanShutdown(TestReactorMixin, unittest.TestCase):

    def setUp(self):
        self.setUpTestReactor()
        self.master = fakemaster.make_master(self, wantData=True)
        self.botmaster = BotMaster()
        self.botmaster.setServiceParent(self.master)
        self.botmaster.startService()

    def assertReactorStopped(self, _=None):
        self.assertTrue(self.reactor.stop_called)

    def assertReactorNotStopped(self, _=None):
        self.assertFalse(self.reactor.stop_called)

    def makeFakeBuild(self, waitedFor=False):
        self.fake_builder = builder = mock.Mock()
        build_status = mock.Mock()
        builder.builder_status.getCurrentBuilds.return_value = [build_status]
        self.build_deferred = defer.Deferred()

        request = mock.Mock()
        request.waitedFor = waitedFor
        build = mock.Mock()
        build.stopBuild = self.stopFakeBuild
        build.waitUntilFinished.return_value = self.build_deferred
        build.requests = [request]
        builder.building = [build]

        self.botmaster.builders = mock.Mock()
        self.botmaster.builders.values.return_value = [builder]

    def stopFakeBuild(self, reason, results):
        self.reason = reason
        self.results = results
        self.finishFakeBuild()

    def finishFakeBuild(self):
        self.fake_builder.building = []
        self.build_deferred.callback(None)

    # tests

    def test_shutdown_idle(self):
        """Test that the master shuts down when it's idle"""
        self.botmaster.cleanShutdown(_reactor=self.reactor)
        self.assertReactorStopped()

    def test_shutdown_busy(self):
        """Test that the master shuts down after builds finish"""
        self.makeFakeBuild()

        self.botmaster.cleanShutdown(_reactor=self.reactor)

        # check that we haven't stopped yet, since there's a running build
        self.assertReactorNotStopped()

        # try to shut it down again, just to check that this does not fail
        self.botmaster.cleanShutdown(_reactor=self.reactor)

        # Now we cause the build to finish
        self.finishFakeBuild()

        # And now we should be stopped
        self.assertReactorStopped()

    def test_shutdown_busy_quick(self):
        """Test that the master shuts down after builds finish"""
        self.makeFakeBuild()

        self.botmaster.cleanShutdown(quickMode=True, _reactor=self.reactor)

        # And now we should be stopped
        self.assertReactorStopped()
        self.assertEqual(self.results, RETRY)

    def test_shutdown_busy_quick_cancelled(self):
        """Test that the master shuts down after builds finish"""
        self.makeFakeBuild(waitedFor=True)

        self.botmaster.cleanShutdown(quickMode=True, _reactor=self.reactor)

        # And now we should be stopped
        self.assertReactorStopped()
        self.assertEqual(self.results, CANCELLED)

    def test_shutdown_cancel_not_shutting_down(self):
        """Test that calling cancelCleanShutdown when none is in progress
        works"""
        # this just shouldn't fail..
        self.botmaster.cancelCleanShutdown()

    def test_shutdown_cancel(self):
        """Test that we can cancel a shutdown"""
        self.makeFakeBuild()

        self.botmaster.cleanShutdown(_reactor=self.reactor)

        # Next we check that we haven't stopped yet, since there's a running
        # build.
#.........这里部分代码省略.........