def test_getBuildRequests_bsid_arg(self):
d = self.insertTestData([
# the buildset that we are *not* looking for
fakedb.Buildset(id=self.BSID+1, sourcestampid=234),
fakedb.BuildRequest(id=70, buildsetid=self.BSID,
complete=0, complete_at=None),
fakedb.BuildRequest(id=71, buildsetid=self.BSID+1,
complete=0, complete_at=None),
fakedb.BuildRequest(id=72, buildsetid=self.BSID,
complete=0, complete_at=None),
])
d.addCallback(lambda _ :
self.db.buildrequests.getBuildRequests(bsid=self.BSID))
def check(brlist):
self.assertEqual(sorted([ br['brid'] for br in brlist ]),
sorted([70, 72]))
d.addCallback(check)
return d
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_getBuildset_complete(self):
d = self.insertTestData([
fakedb.Buildset(id=91,
complete=1,
complete_at=298297875,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn'),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
])
d.addCallback(lambda _: self.db.buildsets.getBuildset(91))
def check(bsdict):
validation.verifyDbDict(self, 'bsdict', bsdict)
self.assertEqual(
bsdict,
dict(external_idstring='extid',
reason='rsn',
sourcestamps=[234],
submitted_at=datetime.datetime(1978,
6,
15,
12,
31,
15,
tzinfo=UTC),
complete=True,
complete_at=datetime.datetime(1979,
6,
15,
12,
31,
15,
tzinfo=UTC),
results=-1,
bsid=91,
parent_buildid=None,
parent_relationship=None))
d.addCallback(check)
return d
def test_setBuildProperties(self):
self.master.db.insertTestData([
fakedb.Buildset(id=28),
fakedb.BuildRequest(id=5, buildsetid=28),
fakedb.Master(id=3),
fakedb.Worker(id=42, name="Friday"),
fakedb.Build(id=1234, buildrequestid=5, masterid=3, workerid=42),
])
self.master.db.builds.setBuildProperty = mock.Mock(
wraps=self.master.db.builds.setBuildProperty)
props = processProperties.fromDict(
dict(a=(1, 't'), b=(['abc', 9], 't')))
yield self.rtype.setBuildProperties(1234, props)
self.master.db.builds.setBuildProperty.assert_has_calls([
mock.call(1234, u'a', 1, u't'),
mock.call(1234, u'b', ['abc', 9], u't')
])
self.master.mq.assertProductions([
(('builds', '1234', 'properties', 'update'), {
u'a': (1, u't'),
u'b': (['abc', 9], u't')
}),
])
# sync without changes: no db write
self.master.db.builds.setBuildProperty.reset_mock()
self.master.mq.clearProductions()
yield self.rtype.setBuildProperties(1234, props)
self.master.db.builds.setBuildProperty.assert_not_called()
self.master.mq.assertProductions([])
# sync with one changes: one db write
props.setProperty('b', 2, 'step')
self.master.db.builds.setBuildProperty.reset_mock()
yield self.rtype.setBuildProperties(1234, props)
self.master.db.builds.setBuildProperty.assert_called_with(
1234, u'b', 2, u'step')
self.master.mq.assertProductions([(('builds', '1234', 'properties',
'update'), {
u'b': (2, u'step')
})])
def do_test(self, scheduler_name, expect_subscription,
result, expect_buildset):
sched = self.makeScheduler()
sched.startService()
callbacks = self.master.getSubscriptionCallbacks()
# pretend we saw a buildset with a matching name
self.db.insertTestData([
fakedb.SourceStamp(id=93, sourcestampsetid=1093, revision='555',
branch='master', project='proj', repository='repo',
codebase = 'cb'),
fakedb.Buildset(id=44, sourcestampsetid=1093),
])
callbacks['buildsets'](bsid=44,
properties=dict(scheduler=(scheduler_name, 'Scheduler')))
# check whether scheduler is subscribed to that buildset
if expect_subscription:
self.assertBuildsetSubscriptions([44])
else:
self.assertBuildsetSubscriptions([])
# pretend that the buildset is finished
self.db.buildsets.fakeBuildsetCompletion(bsid=44, result=result)
callbacks['buildset_completion'](44, result)
# and check whether a buildset was added in response
if expect_buildset:
self.db.buildsets.assertBuildsets(2)
bsids = self.db.buildsets.allBuildsetIds()
bsids.remove(44)
self.db.buildsets.assertBuildset(bsids[0],
dict(external_idstring=None,
properties=[('scheduler', ('n', 'Scheduler'))],
reason='downstream', sourcestampsetid = 1093),
{'cb':
dict(revision='555', branch='master', project='proj',
repository='repo', codebase='cb',
sourcestampsetid = 1093)
})
else:
self.db.buildsets.assertBuildsets(1) # only the one we added above
def test_fromBrdict_multiple_sourcestamps(self):
master = fakemaster.make_master(testcase=self,
wantData=True, wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=234, branch='trunk',
revision='9283', repository='svn://a..',
codebase='A', project='world-domination'),
fakedb.Change(changeid=13, branch='trunk', revision='9283',
repository='svn://a..', codebase='A',
project='world-domination', sourcestampid=234),
fakedb.SourceStamp(id=235, branch='trunk',
revision='9284', repository='svn://b..',
codebase='B', project='world-domination'),
fakedb.Change(changeid=14, branch='trunk', revision='9284',
repository='svn://b..', codebase='B',
project='world-domination', sourcestampid=235),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=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, builderid=77,
priority=13, submitted_at=1200000000),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
brdict = yield master.db.buildrequests.getBuildRequest(288)
br = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
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)
def setUp(self):
self.botmaster = mock.Mock(name='botmaster')
self.botmaster.builders = {}
self.master = self.botmaster.master = mock.Mock(name='master')
self.master.db = fakedb.FakeDBConnector(self)
class getCache(object):
def get_cache(self):
return self
def get(self, name):
return
self.master.caches = fakemaster.FakeCaches()
self.brd = buildrequestdistributor.BuildRequestDistributor(
self.botmaster)
self.brd.startService()
self.startedBuilds = []
# 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.bldr = self.createBuilder('A')
# a collection of rows that would otherwise clutter up every test
self.base_rows = [
fakedb.SourceStampSet(id=21),
fakedb.SourceStamp(id=21, sourcestampsetid=21),
fakedb.Buildset(id=11, reason='because', sourcestampsetid=21),
]
def test_brdictToBuildRequest(self):
wfd = defer.waitForDeferred(self.makeBuilder())
yield wfd
wfd.getResult()
# set up all of the data required for a BuildRequest object
wfd = defer.waitForDeferred(
self.db.insertTestData([
fakedb.SourceStampSet(id=234),
fakedb.SourceStamp(id=234, sourcestampsetid=234),
fakedb.Buildset(id=30,
sourcestampsetid=234,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildRequest(id=19,
buildsetid=30,
buildername='bldr',
priority=13,
submitted_at=1300305712,
results=-1),
]))
yield wfd
wfd.getResult()
wfd = defer.waitForDeferred(self.db.buildrequests.getBuildRequest(19))
yield wfd
brdict = wfd.getResult()
wfd = defer.waitForDeferred(self.bldr._brdictToBuildRequest(brdict))
yield wfd
br = wfd.getResult()
# just check that the BuildRequest looks reasonable -
# test_process_buildrequest checks the whole thing
self.assertEqual(br.reason, 'foo')
# and check that the cross-pointers are correct
self.assertIdentical(br.brdict, brdict)
self.assertIdentical(brdict['brobj'], br)
self.bldr._breakBrdictRefloops([brdict])
def test_getBuildset_complete(self):
d = self.insertTestData([
fakedb.Buildset(id=91, sourcestampid=234, complete=1,
complete_at=298297875, results=-1, submitted_at=266761875,
external_idstring='extid', reason='rsn'),
])
d.addCallback(lambda _ :
self.db.buildsets.getBuildset(91))
def check(bsdict):
self.assertEqual(bsdict, dict(external_idstring='extid',
reason='rsn', sourcestampid=234,
submitted_at=datetime.datetime(1978, 6, 15, 12, 31, 15,
tzinfo=UTC),
complete=True,
complete_at=datetime.datetime(1979, 6, 15, 12, 31, 15,
tzinfo=UTC),
results=-1,
bsid=91))
d.addCallback(check)
return d
def test_fromBrdict_no_sourcestamps(self):
master = fakemaster.make_master(testcase=self,
wantData=True,
wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=78, name='not important'),
fakedb.Buildset(id=539, reason='triggered'),
# buildset has no sourcestamps
fakedb.BuildRequest(id=288,
buildsetid=539,
builderid=78,
priority=0,
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))
return self.assertFailure(d, AssertionError)
def test_fromBrdict_submittedAt_NULL(self):
master = fakemaster.make_master(testcase=self,
wantData=True, wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=234, branch='trunk',
revision='9284', repository='svn://...',
project='world-domination'),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=234),
fakedb.BuildRequest(id=288, buildsetid=539, builderid=77,
priority=13, submitted_at=None),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
brdict = yield master.db.buildrequests.getBuildRequest(288)
br = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
# remaining fields assumed to be checked in test_fromBrdict
self.assertEqual(br.submittedAt, None)
def setUp(self):
# a collection of rows that would otherwise clutter up every test
master_id = fakedb.FakeBuildRequestsComponent.MASTER_ID
self.base_rows = [
fakedb.SourceStampSet(id=21),
fakedb.SourceStamp(id=21, sourcestampsetid=21),
fakedb.Buildset(id=11, reason='because', sourcestampsetid=21),
fakedb.BuildRequest(id=111, submitted_at=1000,
buildername='bldr1', buildsetid=11),
fakedb.BuildRequest(id=222, submitted_at=2000,
buildername='bldr1', buildsetid=11),
fakedb.BuildRequestClaim(brid=222, objectid=master_id,
claimed_at=2001),
fakedb.BuildRequest(id=333, submitted_at=3000,
buildername='bldr1', buildsetid=11),
fakedb.BuildRequest(id=444, submitted_at=2500,
buildername='bldr2', buildsetid=11),
fakedb.BuildRequestClaim(brid=444, objectid=master_id,
claimed_at=2501),
]
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77, name='bbb'),
fakedb.Master(id=fakedb.FakeBuildRequestsComponent.MASTER_ID),
fakedb.Worker(id=13, name='wrk'),
fakedb.Buildset(id=8822),
fakedb.BuildRequest(id=44,
buildsetid=8822,
builderid=77,
priority=7,
submitted_at=self.SUBMITTED_AT_EPOCH,
waited_for=1),
fakedb.BuildsetProperty(buildsetid=8822,
property_name='prop1',
property_value='["one", "fake1"]'),
fakedb.BuildsetProperty(buildsetid=8822,
property_name='prop2',
property_value='["two", "fake2"]'),
])
def test_results_are_correctly_limited_by_builds_count(self):
builds_count = self.mybuild_limit + 10
example_data = [
fakedb.Buildset(id=2, sourcestampsetid=2, reason='[ first_user ]'),
fakedb.BuildRequest(id=3,
buildsetid=2,
buildername="builder2",
complete=1,
results=7),
] + [
fakedb.Build(id=i, number=i + 2, brid=3, slavename='slave-02')
for i in xrange(builds_count)
]
yield self.insertTestData(example_data)
first_user_builds = yield self.db.builds.getLastBuildsOwnedBy(
"first_user", FakeBotMaster(self.master))
self.assertEqual(len(first_user_builds), self.mybuild_limit)
self.assertEqual(self._collect_ids(first_user_builds, 'builds_id'),
range(self.mybuild_limit))
def test_pollDatabaseBuildRequests_new(self):
self.db.insertTestData([
fakedb.SourceStampSet(id=127),
fakedb.SourceStamp(id=127, sourcestampsetid=127),
fakedb.Buildset(id=99, sourcestampsetid=127),
fakedb.BuildRequest(id=19, buildsetid=99, buildername='9teen'),
fakedb.BuildRequest(id=20, buildsetid=99, buildername='twenty')
])
d = self.master.pollDatabaseBuildRequests()
def check(_):
self.assertEqual(
sorted(self.gotten_buildrequest_additions),
sorted([
dict(bsid=99, brid=19, buildername='9teen'),
dict(bsid=99, brid=20, buildername='twenty')
]))
d.addCallback(check)
return d
def test_mergeRequests(self):
yield self.makeBuilder()
# set up all of the data required for a BuildRequest object
yield self.db.insertTestData([
fakedb.SourceStampSet(id=234),
fakedb.SourceStamp(id=234, sourcestampsetid=234),
fakedb.Buildset(id=30, sourcestampsetid=234, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=19, buildsetid=30, buildername='bldr',
priority=13, submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=20, buildsetid=30, buildername='bldr',
priority=13, submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=21, buildsetid=30, buildername='bldr',
priority=13, submitted_at=1300305712, results=-1),
])
brdicts = yield defer.gatherResults([
self.db.buildrequests.getBuildRequest(id)
for id in (19, 20, 21)
])
def mergeRequests_fn(builder, breq, other):
# merge evens with evens, odds with odds
return breq.id % 2 == other.id % 2
# check odds
odds = yield self.bldr._mergeRequests(brdicts[0],
brdicts, mergeRequests_fn)
self.assertEqual(odds, [ brdicts[0], brdicts[2] ])
# check evens
evens = yield self.bldr._mergeRequests(brdicts[1],
brdicts, mergeRequests_fn)
self.assertEqual(evens, [ brdicts[1] ])
# check original relative order of requests within brdicts is maintained
merged = yield self.bldr._mergeRequests(brdicts[2],
brdicts, mergeRequests_fn)
self.assertEqual(merged, [brdicts[0], brdicts[2]],
'relative order of merged requests was not maintained')
def setUp(self):
self.setUpTestReactor()
self.setUpBuilderMixin()
# a collection of rows that would otherwise clutter up every test
master_id = fakedb.FakeBuildRequestsComponent.MASTER_ID
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(buildsetid=11, sourcestampid=21),
fakedb.Builder(id=77, name='bldr1'),
fakedb.Builder(id=78, name='bldr2'),
fakedb.Builder(id=182, name='foo@bar'),
fakedb.BuildRequest(id=111,
submitted_at=1000,
builderid=77,
buildsetid=11),
fakedb.BuildRequest(id=222,
submitted_at=2000,
builderid=77,
buildsetid=11),
fakedb.BuildRequestClaim(brid=222,
masterid=master_id,
claimed_at=2001),
fakedb.BuildRequest(id=333,
submitted_at=3000,
builderid=77,
buildsetid=11),
fakedb.BuildRequest(id=444,
submitted_at=2500,
builderid=78,
buildsetid=11),
fakedb.BuildRequestClaim(brid=444,
masterid=master_id,
claimed_at=2501),
fakedb.BuildRequest(id=555,
submitted_at=2800,
builderid=182,
buildsetid=11),
]
yield self.db.insertTestData(self.base_rows)
def test_fromBrdict(self):
master = fakemaster.make_master(testcase=self,
wantData=True, wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=234, branch='trunk',
revision='9284', repository='svn://...',
project='world-domination'),
fakedb.Change(changeid=13, branch='trunk', revision='9283',
repository='svn://...', project='world-domination',
sourcestampid=234),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=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, builderid=77,
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([ss.ssid for ss in itervalues(br.sources)], [234])
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_mergeRequests(self):
self.makeBuilder()
# set up all of the data required for a BuildRequest object
wfd = defer.waitForDeferred(
self.db.insertTestData([
fakedb.SourceStamp(id=234),
fakedb.Buildset(id=30, sourcestampid=234, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=19, buildsetid=30, buildername='bldr',
priority=13, submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=20, buildsetid=30, buildername='bldr',
priority=13, submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=21, buildsetid=30, buildername='bldr',
priority=13, submitted_at=1300305712, results=-1),
]))
yield wfd
wfd.getResult()
wfd = defer.waitForDeferred(
defer.gatherResults([
self.db.buildrequests.getBuildRequest(id)
for id in (19, 20, 21)
]))
yield wfd
brdicts = wfd.getResult()
def mergeRequests_fn(builder, breq, other):
# merge evens with evens, odds with odds
return breq.id % 2 == other.id % 2
# check odds
wfd = defer.waitForDeferred(
self.bldr._mergeRequests(brdicts[0], brdicts, mergeRequests_fn))
yield wfd
self.assertEqual(wfd.getResult(), [ brdicts[0], brdicts[2] ])
# check evens
wfd = defer.waitForDeferred(
self.bldr._mergeRequests(brdicts[1], brdicts, mergeRequests_fn))
yield wfd
self.assertEqual(wfd.getResult(), [ brdicts[1] ])
def do_test_nextBuild(self, nextBuild, exp_choice=None):
self.bldr.config.nextBuild = nextBuild
self.master.config.mergeRequests = False
rows = self.base_rows[:]
for i in range(4):
rows.append(fakedb.Buildset(id=100 + i, reason='because', sourcestampsetid=21))
rows.append(fakedb.BuildRequest(id=10 + i, buildsetid=100 + i, buildername="A"))
self.addSlaves({'test-slave%d' % i: 1})
exp_claims = []
exp_builds = []
if exp_choice is not None:
slave = 3
for choice in exp_choice:
exp_claims.append(choice)
exp_builds.append(('test-slave%d' % slave, [choice]))
slave = slave - 1
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows,
exp_claims=sorted(exp_claims), exp_builds=exp_builds)
def setUp(self):
d = self.setUpConnectorComponent(
table_names=[ 'patches', 'changes', 'sourcestamp_changes',
'buildsets', 'buildset_properties', 'buildrequests',
'sourcestamps' ])
def finish_setup(_):
self.db.buildrequests = \
buildrequests.BuildRequestsConnectorComponent(self.db)
self.db.master.master_name = self.MASTER_NAME
self.db.master.master_incarnation = self.MASTER_INCARN
d.addCallback(finish_setup)
# set up a sourcestamp and buildset for use below
d.addCallback(lambda _ :
self.insertTestData([
fakedb.SourceStamp(id=234),
fakedb.Buildset(id=self.BSID, sourcestampid=234),
]))
return d
def addBuild(codebase_ss, results=0):
lastID["buildid"] += 1
lastID["buildsetid"] += 1
lastID["buildrequestid"] += 1
buildRows = [
fakedb.Buildset(id=lastID["buildsetid"],
reason='foo',
submitted_at=1300305012,
results=-1)
]
for cb, ss_list in codebase_ss.iteritems():
for ss in ss_list:
lastID["buildsetSourceStampid"] += 1
buildRows.append(
fakedb.BuildsetSourceStamp(
id=lastID["buildsetSourceStampid"],
sourcestampid=ss,
buildsetid=lastID["buildsetid"]))
codebase_ss = {}
buildRows.extend([
fakedb.BuildRequest(id=lastID["buildrequestid"],
buildsetid=lastID["buildsetid"],
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
fakedb.Build(id=lastID["buildid"],
buildrequestid=lastID["buildrequestid"],
number=lastID["buildid"],
masterid=88,
builderid=77,
state_string="test",
buildslaveid=13,
started_at=SOMETIME + lastID["buildid"],
complete_at=SOMETIME + 2 * lastID["buildid"],
results=results)
])
return buildRows
def testRebuildBuildrequest(self):
self.master.db.insertTestData([
fakedb.Builder(id=77, name='builder'),
fakedb.Master(id=88),
fakedb.Worker(id=13, name='sl'),
fakedb.Buildset(id=8822),
fakedb.SourceStamp(id=234),
fakedb.BuildsetSourceStamp(buildsetid=8822, sourcestampid=234),
fakedb.BuildRequest(id=82, buildsetid=8822, builderid=77),
fakedb.BuildsetProperty(buildsetid=8822, property_name='prop1',
property_value='["one", "fake1"]'),
fakedb.BuildsetProperty(buildsetid=8822, property_name='prop2',
property_value='["two", "fake2"]'),
])
buildrequest = yield self.master.data.get(('buildrequests', 82))
new_bsid, brid_dict = yield self.rtype.rebuildBuildrequest(buildrequest)
self.assertEqual(brid_dict.keys(), [77])
buildrequest = yield self.master.data.get(('buildrequests', brid_dict[77]))
# submitted_at is the time of the test, so better not depend on it
self.assertTrue(buildrequest['submitted_at'] is not None)
buildrequest['submitted_at'] = None
self.assertEqual(buildrequest, {'buildrequestid': 1001, 'complete': False, 'waited_for': False,
'claimed_at': None, 'results': -1, 'claimed': False,
'buildsetid': 200, 'complete_at': None, 'submitted_at': None,
'builderid': 77, 'claimed_by_masterid': None, 'priority': 0})
buildset = yield self.master.data.get(('buildsets', new_bsid))
oldbuildset = yield self.master.data.get(('buildsets', 8822))
# assert same sourcestamp
self.assertEqual(buildset['sourcestamps'], oldbuildset['sourcestamps'])
buildset['sourcestamps'] = None
self.assertTrue(buildset['submitted_at'] is not None)
buildset['submitted_at'] = None
self.assertEqual(buildset, {'bsid': 200, 'complete_at': None, 'submitted_at': None,
'sourcestamps': None, 'parent_buildid': None, 'results': -1, 'parent_relationship': None, 'reason': u'rebuild', 'external_idstring': u'extid', 'complete': False})
properties = yield self.master.data.get(('buildsets', new_bsid, 'properties'))
self.assertEqual(
properties, {u'prop1': (u'one', u'fake1'), u'prop2': (u'two', u'fake2')})
def setUp(self):
self.botmaster = mock.Mock(name='botmaster')
self.botmaster.builders = {}
self.builders = {}
def prioritizeBuilders(master, builders):
# simple sort-by-name by default
return sorted(builders, key=lambda b1: b1.name)
self.master = self.botmaster.master = fakemaster.make_master(
testcase=self, wantData=True, wantDb=True)
self.master.caches = fakemaster.FakeCaches()
self.master.config.prioritizeBuilders = prioritizeBuilders
self.brd = buildrequestdistributor.BuildRequestDistributor(
self.botmaster)
self.brd.parent = 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
# a collection of rows that would otherwise clutter up every test
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Builder(id=77, name='A'),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(sourcestampid=21, buildsetid=11),
]
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77),
fakedb.Master(id=88),
fakedb.Worker(id=13, name='sl'),
fakedb.Buildset(id=8822),
fakedb.BuildRequest(id=82, buildsetid=8822),
fakedb.Build(id=13,
builderid=77,
masterid=88,
workerid=13,
buildrequestid=82,
number=3),
fakedb.Step(id=50, buildid=13, number=9, name='make'),
fakedb.Log(id=60, stepid=50, name='stdio', type='s'),
fakedb.Log(id=61, stepid=50, name='errors', type='t'),
fakedb.Step(id=51, buildid=13, number=10, name='make_install'),
fakedb.Log(id=70, stepid=51, name='stdio', type='s'),
fakedb.Log(id=71, stepid=51, name='results_html', type='h'),
fakedb.Step(id=52, buildid=13, number=11, name='nothing'),
])
def insertTestData(self, buildResults, finalResult):
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='sl'),
fakedb.Builder(id=79, name='Builder0'),
fakedb.Builder(id=80, name='Builder1'),
fakedb.Buildset(id=98, results=finalResult, reason="testReason1"),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(id=234,
project=self.TEST_PROJECT,
revision=self.TEST_REVISION,
repository=self.TEST_REPO),
fakedb.Change(changeid=13, branch=u'master', revision=u'9283', author='me@foo',
repository=self.TEST_REPO, codebase=u'cbgerrit',
project=u'world-domination', sourcestampid=234),
])
for i, results in enumerate(buildResults):
self.db.insertTestData([
fakedb.BuildRequest(
id=11 + i, buildsetid=98, builderid=79 + i),
fakedb.Build(id=20 + i, number=i, builderid=79 + i, buildrequestid=11 + i, workerid=13,
masterid=92, results=results, state_string=u"buildText"),
fakedb.Step(id=50 + i, buildid=20 + i, number=5, name='make'),
fakedb.Log(id=60 + i, stepid=50 + i, name='stdio', slug='stdio', type='s',
num_lines=7),
fakedb.LogChunk(logid=60 + i, first_line=0, last_line=1, compressed=0,
content=u'Unicode log with non-ascii (\u00E5\u00E4\u00F6).'),
fakedb.BuildProperty(
buildid=20 + i, name="workername", value="sl"),
fakedb.BuildProperty(
buildid=20 + i, name="reason", value="because"),
fakedb.BuildProperty(
buildid=20 + i, name="buildername", value="Builder0"),
])
for k, v in iteritems(self.TEST_PROPS):
self.db.insertTestData([
fakedb.BuildProperty(buildid=20 + i, name=k, value=v)
])
def test_getBuildSets(self):
persp = self.makeStatusClientPersp()
self.db.insertTestData([
fakedb.Buildset(id=91,
sourcestampid=234,
complete=0,
complete_at=298297875,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn1'),
])
d = persp.perspective_getBuildSets()
def check(bslist):
self.assertEqual(len(bslist), 1)
self.assertEqual(bslist[0][1], 91)
self.failUnlessIsInstance(bslist[0][0], client.RemoteBuildSet)
d.addCallback(check)
return d
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Worker(id=47, name='linux'),
fakedb.Builder(id=77),
fakedb.Master(id=88),
fakedb.Buildset(id=8822),
fakedb.BuildRequest(id=82, buildsetid=8822),
fakedb.Build(id=30, builderid=77, number=7, masterid=88,
buildrequestid=82, workerid=47),
fakedb.Build(id=31, builderid=77, number=8, masterid=88,
buildrequestid=82, workerid=47),
fakedb.Step(id=70, number=0, name='one', buildid=30,
started_at=TIME1, complete_at=TIME2, results=0),
fakedb.Step(id=71, number=1, name='two', buildid=30,
started_at=TIME2, complete_at=TIME3, results=2,
urls_json='[{"name":"url","url":"http://url"}]'),
fakedb.Step(id=72, number=2, name='three', buildid=30,
started_at=TIME3),
fakedb.Step(id=73, number=0, name='otherbuild', buildid=31,
started_at=TIME2),
])
def setUp(self):
self.MASTER_ID = fakedb.FakeBuildRequestsComponent.MASTER_ID
d = self.setUpConnectorComponent(table_names=[
'patches', 'changes', 'sourcestamp_changes', 'buildsets',
'buildset_properties', 'buildrequests', 'buildrequest_claims',
'sourcestamps'
])
def finish_setup(_):
self.db.buildrequests = \
buildrequests.BuildRequestsConnectorComponent(self.db)
self.db.master.getObjectId = lambda: defer.succeed(self.MASTER_ID)
d.addCallback(finish_setup)
# set up a sourcestamp and buildset for use below
d.addCallback(lambda _: self.insertTestData([
fakedb.SourceStamp(id=234),
fakedb.Buildset(id=self.BSID, sourcestampid=234),
]))
return d
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77, name='builder77'),
fakedb.Master(id=88),
fakedb.Worker(id=13, name='wrk'),
fakedb.Buildset(id=8822),
fakedb.BuildRequest(id=82, buildsetid=8822),
fakedb.Build(id=13,
builderid=77,
masterid=88,
workerid=13,
buildrequestid=82,
number=3),
fakedb.Step(id=50, buildid=13, number=5, name='make'),
fakedb.Log(id=60, stepid=50, name='stdio', slug='stdio', type='s'),
fakedb.Log(id=61,
stepid=50,
name='errors',
slug='errors',
type='t'),
])
