def makeStatus(self):
m = mock.Mock(name='master')
self.db = m.db = fakedb.FakeDBConnector(m, self)
m.basedir = r'C:\BASEDIR'
m.botmaster.builderNames = []
s = master.Status(m)
return s
def setupStep(self, step, brqs=None, winslave=False, sources=None):
steps.BuildStepMixin.setupStep(self, step)
self.remote = '\'[email protected]:/home/srv/web/dir/build/1_17_12_2014_13_31_26_+0000/mydir/myartifact.py\''
self.remote_2 = '\'[email protected]:/home/srv/web/dir/B/2_01_01_1970_00_00_00_+0000/mydir/myartifact.py\''
self.remote_custom = '\'[email protected]:/home/srv/web/dir/foobar/mydir/myartifact.py\''
self.remote_custom_interpolate = '\'[email protected]:/home/srv/web/dir/Art-abcde/mydir/myartifact.py\''
self.local = '\'myartifact.py\''
fake_br = fakedb.BuildRequest(id=1,
buildsetid=1,
buildername="A",
complete=1,
results=0)
fake_br.submittedAt = 1418823086
self.build.requests = [fake_br]
self.build.builder.config.builddir = "build"
m = fakemaster.make_master()
self.build.builder.botmaster = m.botmaster
m.db = fakedb.FakeDBConnector(self)
breqs = [fake_br]
if brqs:
breqs += brqs
self.build.slavebuilder.slave.slave_environ = {}
self.build.sources = sources or {}
if winslave:
self.build.slavebuilder.slave.slave_environ['os'] = 'Windows_NT'
m.db.insertTestData(breqs)
def make_master(_):
# don't create child services
self.patch(master.BuildMaster, 'create_child_services',
lambda self: None)
# patch out a few other annoying things the master likes to do
self.patch(monkeypatches, 'patch_all', lambda: None)
self.patch(signal, 'signal', lambda sig, hdlr: None)
# XXX temporary
self.patch(master, 'Status', lambda master: mock.Mock())
master.BuildMaster.masterHeartbeatService = mock.Mock()
self.reactor = self.make_reactor()
self.master = master.BuildMaster(self.basedir,
reactor=self.reactor,
config_loader=DefaultLoader())
self.master.sendBuildbotNetUsageData = mock.Mock()
self.master.botmaster = FakeBotMaster()
self.db = self.master.db = fakedb.FakeDBConnector(self)
self.db.setServiceParent(self.master)
self.mq = self.master.mq = fakemq.FakeMQConnector(self)
self.mq.setServiceParent(self.master)
self.data = self.master.data = fakedata.FakeDataConnector(
self.master, self)
self.data.setServiceParent(self.master)
def makeStatusClientPersp(self):
m = mock.Mock(name='master')
self.db = m.db = fakedb.FakeDBConnector(self)
m.basedir = r'C:\BASEDIR'
s = master.Status(m)
persp = client.StatusClientPerspective(s)
return persp
def test_BuildRequestControlCancelBuildRequest(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
bldr = mock.Mock(name="bldr")
master.db.insertTestData([
fakedb.BuildRequest(id=1, buildsetid=1, buildername='bldr'),
fakedb.Buildset(id=1, reason='force', sourcestampsetid=1),
fakedb.SourceStampSet(id=1),
fakedb.SourceStamp(id=1, sourcestampsetid=1)
])
d = master.db.buildrequests.getBuildRequest(1)
def checkCanceled(br):
self.assertEquals((br['complete'], br['results']),
(True, CANCELED))
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
d.addCallback(
lambda breq: buildrequest.BuildRequestControl(bldr, breq))
d.addCallback(lambda breqControl: breqControl.cancel())
d.addCallback(lambda _: master.db.buildrequests.getBuildRequest(1))
d.addCallback(checkCanceled)
return d
def setUp(self):
self.clock = task.Clock()
self.clock.advance(SOMETIME)
self.master = fakemaster.make_master()
self.db = fakedb.FakeDBConnector(self.master, self)
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def test_fromSsdict_patch(self):
master = mock.Mock()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.Patch(id=99,
subdir='/foo',
patchlevel=3,
patch_base64='LS0gKys='),
fakedb.SourceStamp(id=234,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination',
patchid=99),
])
# use getSourceStamp to minimize the risk from changes to the format of
# the ssdict
d = master.db.sourcestamps.getSourceStamp(234)
d.addCallback(
lambda ssdict: sourcestamp.SourceStamp.fromSsdict(master, ssdict))
def check(ss):
self.assertEqual(ss.ssid, 234)
self.assertEqual(ss.branch, 'trunk')
self.assertEqual(ss.revision, '9284')
self.assertEqual(ss.patch, (3, '-- ++'))
self.assertEqual(ss.changes, ())
self.assertEqual(ss.project, 'world-domination')
self.assertEqual(ss.repository, 'svn://...')
d.addCallback(check)
return d
def setUp(self):
self.setUpTestReactor()
self.master = fakemaster.make_master(self)
self.db = fakedb.FakeDBConnector(self)
self.db.setServiceParent(self.master)
self.db.checkForeignKeys = True
self.insertTestData = self.db.insertTestData
def test_fromBrdict_submittedAt_NULL(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.SourceStampSet(id=234),
fakedb.SourceStamp(id=234,
sourcestampsetid=234,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination'),
fakedb.Buildset(id=539, reason='triggered', sourcestampsetid=234),
fakedb.BuildRequest(id=288,
buildsetid=539,
buildername='bldr',
priority=13,
submitted_at=None),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
def check(br):
# remaining fields assumed to be checked in test_fromBrdict
self.assertEqual(br.submittedAt, None)
d.addCallback(check)
return d
def make_master(testcase,
wantMq=False,
wantDb=False,
wantData=False,
wantRealReactor=False,
url=None,
**kwargs):
if wantRealReactor:
_reactor = reactor
else:
assert testcase is not None, "need testcase for fake reactor"
# The test case must inherit from TestReactorMixin and setup it.
_reactor = testcase.reactor
master = FakeMaster(_reactor, **kwargs)
if url:
master.buildbotURL = url
if wantData:
wantMq = wantDb = True
if wantMq:
assert testcase is not None, "need testcase for wantMq"
master.mq = fakemq.FakeMQConnector(testcase)
master.mq.setServiceParent(master)
if wantDb:
assert testcase is not None, "need testcase for wantDb"
master.db = fakedb.FakeDBConnector(testcase)
master.db.setServiceParent(master)
if wantData:
master.data = fakedata.FakeDataConnector(master, testcase)
return master
def makeBuilder(self, name="bldr", patch_random=False, **config_kwargs):
"""Set up C{self.bldr}"""
self.factory = factory.BuildFactory()
self.master = fakemaster.make_master()
# only include the necessary required config, plus user-requested
config_args = dict(name=name, slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
config_args.update(config_kwargs)
self.builder_config = config.BuilderConfig(**config_args)
self.bldr = builder.Builder(self.builder_config.name, _addServices=False)
self.master.db = self.db = fakedb.FakeDBConnector(self)
self.bldr.master = self.master
self.bldr.botmaster = self.master.botmaster
# patch into the _startBuildsFor method
self.builds_started = []
def _startBuildFor(slavebuilder, buildrequests):
self.builds_started.append((slavebuilder, buildrequests))
return defer.succeed(True)
self.bldr._startBuildFor = _startBuildFor
if patch_random:
# patch 'random.choice' to always take the slave that sorts
# last, based on its name
self.patch(random, "choice",
lambda lst: sorted(lst, key=lambda m: m.name)[-1])
self.bldr.startService()
mastercfg = config.MasterConfig()
mastercfg.builders = [self.builder_config]
return self.bldr.reconfigService(mastercfg)
def makeBuilder(self, patch_random=False, **config_kwargs):
"""Set up C{self.bldr}"""
self.bstatus = mock.Mock()
self.factory = mock.Mock()
self.master = fakemaster.make_master()
# only include the necessary required config, plus user-requested
config = dict(name="bldr", slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
config.update(config_kwargs)
self.bldr = builder.Builder(config, self.bstatus)
self.master.db = self.db = fakedb.FakeDBConnector(self)
self.bldr.master = self.master
self.bldr.botmaster = self.master.botmaster
# patch into the _startBuildsFor method
self.builds_started = []
def _startBuildFor(slavebuilder, buildrequests):
self.builds_started.append((slavebuilder, buildrequests))
return defer.succeed(True)
self.bldr._startBuildFor = _startBuildFor
if patch_random:
# patch 'random.choice' to always take the slave that sorts
# last, based on its name
self.patch(random, "choice",
lambda lst : sorted(lst, key=lambda m : m.name)[-1])
# we don't want the reclaim service running during tests..
self.bldr.reclaim_svc.disownServiceParent()
self.bldr.startService()
def setUp(self):
self.botmaster = mock.Mock(name='botmaster')
self.botmaster.builders = {}
def prioritizeBuilders(master, builders):
# simple sort-by-name by default
return sorted(builders, lambda b1, b2: cmp(b1.name, b2.name))
self.master = self.botmaster.master = mock.Mock(name='master')
self.master.config.prioritizeBuilders = prioritizeBuilders
self.master.db = fakedb.FakeDBConnector(self)
self.brd = buildrequestdistributor.BuildRequestDistributor(self.botmaster)
self.brd.startService()
# TODO: this is a terrible way to detect the "end" of the test -
# it regularly completes too early after a simple modification of
# a test. Is there a better way?
self.quiet_deferred = defer.Deferred()
def _quiet():
if self.quiet_deferred:
d, self.quiet_deferred = self.quiet_deferred, None
d.callback(None)
else:
self.fail("loop has already gone quiet once")
self.brd._quiet = _quiet
self.builders = {}
def test_fromSsdict_simple(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.SourceStamp(id=234,
sourcestampsetid=234,
branch='trunk',
revision='9284',
repository='svn://...',
codebase='cb',
project='world-domination'),
])
# use getSourceStamp to minimize the risk from changes to the format of
# the ssdict
d = master.db.sourcestamps.getSourceStamp(234)
d.addCallback(
lambda ssdict: sourcestamp.SourceStamp.fromSsdict(master, ssdict))
def check(ss):
self.assertEqual(ss.ssid, 234)
self.assertEqual(ss.branch, 'trunk')
self.assertEqual(ss.revision, '9284')
self.assertEqual(ss.patch, None)
self.assertEqual(ss.patch_info, None)
self.assertEqual(ss.changes, ())
self.assertEqual(ss.project, 'world-domination')
self.assertEqual(ss.repository, 'svn://...')
self.assertEqual(ss.codebase, 'cb')
d.addCallback(check)
return d
def test_buildsetFinished_sends_email(self):
fakeBuildMessage = Mock()
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode=("failing", "passing", "warnings"),
builders=["Builder1", "Builder2"])
mn.buildMessage = fakeBuildMessage
builder1 = Mock()
builder1.getBuild = lambda number: build1
builder1.name = "Builder1"
build1 = FakeBuildStatus()
build1.results = FAILURE
build1.finished = True
build1.reason = "testReason"
build1.getBuilder.return_value = builder1
builder2 = Mock()
builder2.getBuild = lambda number: build2
builder2.name = "Builder2"
build2 = FakeBuildStatus()
build2.results = FAILURE
build2.finished = True
build2.reason = "testReason"
build2.getBuilder.return_value = builder1
def fakeGetBuilder(buildername):
return {"Builder1": builder1, "Builder2": builder2}[buildername]
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([
fakedb.SourceStampSet(id=127),
fakedb.Buildset(id=99,
sourcestampsetid=127,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99, buildername='Builder1'),
fakedb.Build(number=0, brid=11),
fakedb.BuildRequest(id=12, buildsetid=99, buildername='Builder2'),
fakedb.Build(number=0, brid=12),
])
mn.master = self # FIXME: Should be FakeMaster
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict = Mock()
mn.buildMessageDict.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
mn.buildsetFinished(99, FAILURE)
fakeBuildMessage.assert_called_with("(whole buildset)",
[build1, build2], SUCCESS)
def setupStep(self,
step,
sourcestampsInBuild=None,
gotRevisionsInBuild=None,
*args,
**kwargs):
sourcestamps = sourcestampsInBuild or []
got_revisions = gotRevisionsInBuild or {}
steps.BuildStepMixin.setupStep(self, step, *args, **kwargs)
# This step reaches deeply into a number of parts of Buildbot. That
# should be fixed!
# set up a buildmaster that knows about two fake schedulers, a and b
m = fakemaster.make_master()
self.build.builder.botmaster = m.botmaster
m.db = fakedb.FakeDBConnector(self)
m.status = master.Status(m)
m.config.buildbotURL = "baseurl/"
self.scheduler_a = a = FakeTriggerable(name='a')
self.scheduler_b = b = FakeTriggerable(name='b')
def allSchedulers():
return [a, b]
m.allSchedulers = allSchedulers
a.brids = {'A': 11}
b.brids = {'B': 22}
make_fake_br = lambda brid, name: fakedb.BuildRequest(
id=brid, buildsetid=BRID_TO_BSID(brid), buildername=name)
make_fake_build = lambda brid: fakedb.Build(
brid=brid, id=BRID_TO_BID(brid), number=BRID_TO_BUILD_NUMBER(brid))
m.db.insertTestData([
make_fake_br(11, "A"),
make_fake_br(22, "B"),
make_fake_build(11),
make_fake_build(22),
])
def getAllSourceStamps():
return sourcestamps
self.build.getAllSourceStamps = getAllSourceStamps
def getAllGotRevisions():
return got_revisions
self.build.build_status.getAllGotRevisions = getAllGotRevisions
self.exp_add_sourcestamp = None
self.exp_a_trigger = None
self.exp_b_trigger = None
self.exp_added_urls = []
def setupStep(self, *args, **kwargs):
steps.BuildStepMixin.setupStep(self, *args, **kwargs)
# This step reaches deeply into a number of parts of Buildbot. That
# should be fixed!
# set up a buildmaster that knows about two fake schedulers, a and b
self.build.builder.botmaster.parent = m = fakemaster.make_master()
m.db = fakedb.FakeDBConnector(self)
m.status = master.Status(m)
m.config.buildbotURL = "baseurl/"
self.scheduler_a = a = FakeTriggerable(name='a', builderNames=['A'])
self.scheduler_b = b = FakeTriggerable(name='b', builderNames=['B'])
def allSchedulers():
return [a, b]
m.allSchedulers = allSchedulers
a.brids = {'A': 11}
b.brids = {'B': 22}
make_fake_br = lambda brid, name: fakedb.BuildRequest(
id=brid, buildsetid=BRID_TO_BSID(brid), buildername=name)
make_fake_build = lambda brid: fakedb.Build(
brid=brid, id=BRID_TO_BID(brid), number=BRID_TO_BUILD_NUMBER(brid))
m.db.insertTestData([
make_fake_br(11, "A"),
make_fake_br(22, "B"),
make_fake_build(11),
make_fake_build(22),
])
# the build has a getSourceStamp method
def getSourceStamp():
return FakeSourceStamp(self.THIS_SSID, self.THIS_SS_SETID)
self.build.getSourceStamp = getSourceStamp
# the db has a addSourceStamp method
def addSourceStamp(**kwargs):
self.addSourceStamp_kwargs = kwargs
return defer.succeed(self.NEW_SSID)
m.db.sourcestamps.addSourceStamp = addSourceStamp
# the db has a addSourceStampSet method
def addSourceStampSet():
return defer.succeed(self.NEW_SS_SETID)
m.db.sourcestampsets.addSourceStampSet = addSourceStampSet
self.exp_add_sourcestamp = None
self.exp_a_trigger = None
self.exp_b_trigger = None
self.exp_added_urls = []
def test_buildsetFinished_sends_email(self):
fakeBuildMessage = Mock()
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode=("failing", "passing", "warnings"),
builders=["Builder"])
mn.buildMessage = fakeBuildMessage
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername": "Builder", "brid": 1}])
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = FakeBuildStatus()
build.results = FAILURE
build.finished = True
build.reason = "testReason"
build.getBuilder.return_value = builder
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([
fakedb.SourceStampSet(id=127),
fakedb.Buildset(id=99,
sourcestampsetid=127,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99, buildername='Builder'),
fakedb.Build(number=0, brid=11),
])
mn.master = self # FIXME: Should be FakeMaster
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict = Mock()
mn.buildMessageDict.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
mn.buildsetFinished(99, FAILURE)
fakeBuildMessage.assert_called_with("Buildset Complete: testReason",
[build], SUCCESS)
def test_TriggerStepMultiMasterMode(self):
m = fakemaster.FakeMaster()
m.maybeStartBuildsForSlave = lambda slave: True
m.status = master.Status(m)
m.config.buildbotURL = "baseurl/"
m.config.multiMaster = True
m.db = fakedb.FakeDBConnector(self)
scheduler_a = FakeTriggerable(name='a')
m.allSchedulers = lambda: [scheduler_a]
def trigger_sch(sourcestamps = None, set_props=None, triggeredbybrid=None, reason=None):
rows = [ fakedb.MasterConfig(id=1, buildbotURL="build-master-01/", objectid=1),
fakedb.MasterConfig(id=2, buildbotURL="build-master-02/", objectid=2),
fakedb.SourceStampSet(id=1),
fakedb.SourceStamp(id=1, sourcestampsetid=1, codebase='c',
branch="az", repository="xz", revision="ww"),
fakedb.Buildset(id=1, reason='because', sourcestampsetid=1),
fakedb.BuildRequest(id=1, buildsetid=1, buildername="builder1", submitted_at=130000),
fakedb.BuildRequest(id=2, buildsetid=1, buildername="builder2", submitted_at=130000),
fakedb.BuildRequestClaim(brid=1, objectid=2, claimed_at=130000),
fakedb.BuildRequestClaim(brid=2, objectid=1, claimed_at=130000),
fakedb.Build(id=1, number=1, brid=1),
fakedb.Build(id=2, number=1, brid=2)]
d = m.db.insertTestData(rows)
d.addCallback(lambda _: (SUCCESS, {'builder1': 1L, 'builder2': 2L}))
return d
scheduler_a.trigger = trigger_sch
self.step = trigger.Trigger(schedulerNames=['a'], waitForFinish=True)
self.step.addCompleteLog = lambda x,y: True
self.step.step_status = Mock()
self.step.step_status.getLogs = lambda: []
self.expected_urls = []
self.step.step_status.addURL = lambda text, path, results=None: \
self.expected_urls.append({'text': text, 'path': path})
self.step.build = fakebuild.FakeBuild()
self.step.build.builder.botmaster = m.botmaster
self.step.build.getAllSourceStamps = lambda: []
self.step.build.build_status.getAllGotRevisions = lambda: {}
request = Mock()
request.id = 1
self.step.build.requests = [request]
self.remote = Mock(name="SlaveBuilder(remote)")
yield self.step.startStep(self.remote)
self.assertEquals(len(self.expected_urls), 2)
self.assertTrue({'text': 'builder1 #1', 'path': 'build-master-02/builders/builder1/builds/1'}
in self.expected_urls)
self.assertTrue({'text': 'builder1 #1', 'path': 'build-master-02/builders/builder1/builds/1'}
in self.expected_urls)
def test_fromBrdict(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.Change(changeid=13,
branch='trunk',
revision='9283',
repository='svn://...',
project='world-domination'),
fakedb.SourceStampSet(id=234),
fakedb.SourceStamp(id=234,
sourcestampsetid=234,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination'),
fakedb.SourceStampChange(sourcestampid=234, changeid=13),
fakedb.Buildset(id=539, reason='triggered', sourcestampsetid=234),
fakedb.BuildsetProperty(buildsetid=539,
property_name='x',
property_value='[1, "X"]'),
fakedb.BuildsetProperty(buildsetid=539,
property_name='y',
property_value='[2, "Y"]'),
fakedb.BuildRequest(id=288,
buildsetid=539,
buildername='bldr',
priority=13,
submitted_at=1200000000),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
def check(br):
# check enough of the source stamp to verify it found the changes
self.assertEqual(br.source.ssid, 234)
self.assertEqual([ch.number for ch in br.source.changes], [13])
self.assertEqual(br.reason, 'triggered')
self.assertEqual(br.properties.getProperty('x'), 1)
self.assertEqual(br.properties.getProperty('y'), 2)
self.assertEqual(br.submittedAt, 1200000000)
self.assertEqual(br.buildername, 'bldr')
self.assertEqual(br.priority, 13)
self.assertEqual(br.id, 288)
self.assertEqual(br.bsid, 539)
d.addCallback(check)
return d
def test_fromSsdict_changes(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
master.db.insertTestData([
fakedb.Change(changeid=13,
branch='trunk',
revision='9283',
repository='svn://...',
project='world-domination'),
fakedb.Change(changeid=14,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination'),
fakedb.Change(changeid=15,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination'),
fakedb.Change(changeid=16,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination'),
fakedb.SourceStamp(id=234,
branch='trunk',
revision='9284',
repository='svn://...',
project='world-domination'),
fakedb.SourceStampChange(sourcestampid=234, changeid=14),
fakedb.SourceStampChange(sourcestampid=234, changeid=13),
fakedb.SourceStampChange(sourcestampid=234, changeid=15),
fakedb.SourceStampChange(sourcestampid=234, changeid=16),
])
# use getSourceStamp to minimize the risk from changes to the format of
# the ssdict
d = master.db.sourcestamps.getSourceStamp(234)
d.addCallback(
lambda ssdict: sourcestamp.SourceStamp.fromSsdict(master, ssdict))
def check(ss):
self.assertEqual(ss.ssid, 234)
self.assertEqual(ss.branch, 'trunk')
self.assertEqual(ss.revision, '9284')
self.assertEqual(ss.patch, None)
self.assertEqual(ss.patch_info, None)
self.assertEqual([ch.number for ch in ss.changes],
[13, 14, 15, 16])
self.assertEqual(ss.project, 'world-domination')
self.assertEqual(ss.repository, 'svn://...')
d.addCallback(check)
return d
def run_fake_build(self, notifier, info=None):
notifier.master = fakemaster.make_master()
notifier.master_status = notifier.master.status
builders = []
builds = []
for i in [0, 1, 2]:
builder = Mock()
build = FakeBuildStatus()
builder.getBuild.return_value = build
builder.name = "Builder%d" % i
build.results = SUCCESS
build.finished = True
build.reason = "testReason"
build.getBuilder.return_value = builder
builders.append(builder)
builds.append(build)
def fakeGetBuilder(buildername):
return {
"Builder0": builders[0],
"Builder1": builders[1],
"Builder2": builders[2]
}[buildername]
notifier.master_status.getBuilder = fakeGetBuilder
notifier.master.db = fakedb.FakeDBConnector(self)
notifier.master.db.insertTestData([
fakedb.SourceStampSet(id=127),
fakedb.Buildset(id=99,
sourcestampsetid=127,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=10, buildsetid=99, buildername="Builder0"),
fakedb.Build(number=0, brid=10),
fakedb.BuildRequest(id=11, buildsetid=99, buildername="Builder1"),
fakedb.Build(number=0, brid=11),
fakedb.BuildRequest(id=12, buildsetid=99, buildername="Builder2"),
fakedb.Build(number=0, brid=12)
])
if info is not None:
info['bsid'] = 99
info['builds'] = builds
d = notifier._buildsetComplete(99, SUCCESS)
return d
def set_master(_):
self.master = master.BuildMaster(basedir)
self.db = self.master.db = fakedb.FakeDBConnector(self)
self.master.db_poll_interval = 10
# overridesubscription callbacks
self.master._change_subs = sub = mock.Mock()
sub.deliver = self.deliverChange
self.master._new_buildset_subs = sub = mock.Mock()
sub.deliver = self.deliverBuildsetAddition
self.master._complete_buildset_subs = sub = mock.Mock()
sub.deliver = self.deliverBuildsetCompletion
def make_master(_):
# don't create child services
self.patch(master.BuildMaster, 'create_child_services',
lambda self : None)
# patch out a few other annoying things the msater likes to do
self.patch(monkeypatches, 'patch_all', lambda : None)
self.patch(signal, 'signal', lambda sig, hdlr : None)
self.patch(master, 'Status', lambda master : mock.Mock()) # XXX temporary
self.patch(config.MasterConfig, 'loadConfig',
classmethod(lambda cls, b, f : cls()))
self.master = master.BuildMaster(self.basedir)
self.db = self.master.db = fakedb.FakeDBConnector(self)
def make_master(wantMq=False, wantDb=False, wantData=False,
testcase=None, **kwargs):
master = FakeMaster(**kwargs)
if wantData:
wantMq = wantDb = True
if wantMq:
assert testcase is not None, "need testcase for wantMq"
master.mq = fakemq.FakeMQConnector(master, testcase)
if wantDb:
assert testcase is not None, "need testcase for wantDb"
master.db = fakedb.FakeDBConnector(master, testcase)
if wantData:
master.data = fakedata.FakeDataConnector(master, testcase)
return master
def makeBuilder(self, name):
self.bstatus = mock.Mock()
self.factory = mock.Mock()
self.master = fakemaster.make_master()
# only include the necessary required config
config = dict(name=name, slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
self.bldr = builder.Builder(config, self.bstatus)
self.master.db = self.db = fakedb.FakeDBConnector(self)
self.bldr.master = self.master
# we don't want the reclaim service running during tests..
self.bldr.reclaim_svc.disownServiceParent()
self.bldr.startService()
def makeBuilder(self, name, sourcestamps):
self.bstatus = mock.Mock()
bstatus_properties = mock.Mock()
bstatus_properties.properties = {}
self.bstatus.getProperties.return_value = bstatus_properties
self.bstatus.getSourceStamps.return_value = sourcestamps
self.factory = mock.Mock()
self.master = fakemaster.make_master()
# only include the necessary required config
builder_config = config.BuilderConfig(
name=name, slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
self.bldr = builder.Builder(builder_config.name)
self.master.db = self.db = fakedb.FakeDBConnector(self)
self.bldr.master = self.master
self.bldr.master.master.addBuildset.return_value = (1, [100])
def attachScheduler(self, scheduler, schedulerid):
"""Set up a scheduler with a fake master and db; sets self.sched, and
sets the master's basedir to the absolute path of 'basedir' in the test
directory.
@returns: scheduler
"""
scheduler.schedulerid = schedulerid
# set up a fake master
db = self.db = fakedb.FakeDBConnector(self)
self.master = FakeMaster(os.path.abspath('basedir'), db)
scheduler.master = self.master
self.sched = scheduler
return scheduler
def makeBuilder(self, name):
self.bstatus = mock.Mock()
self.factory = mock.Mock()
self.master = fakemaster.make_master()
# only include the necessary required config
builder_config = config.BuilderConfig(
name=name, slavename="slv", builddir="bdir",
slavebuilddir="sbdir", factory=self.factory)
self.bldr = builder.Builder(builder_config.name, _addServices=False)
self.master.db = self.db = fakedb.FakeDBConnector(self)
self.bldr.master = self.master
self.bldr.startService()
mastercfg = config.MasterConfig()
mastercfg.builders = [ builder_config ]
return self.bldr.reconfigService(mastercfg)
def make_master(wantMq=False, wantDb=False, wantData=False,
testcase=None, url=None, **kwargs):
master = FakeMaster(**kwargs)
if url:
master.buildbotURL = url
if wantData:
wantMq = wantDb = True
if wantMq:
assert testcase is not None, "need testcase for wantMq"
master.mq = fakemq.FakeMQConnector(testcase)
master.mq.setServiceParent(master)
if wantDb:
assert testcase is not None, "need testcase for wantDb"
master.db = fakedb.FakeDBConnector(testcase)
master.db.setServiceParent(master)
if wantData:
master.data = fakedata.FakeDataConnector(master, testcase)
return master
