def test_collapseRequests_no_collapse(self):
def collapseRequests_fn(builder, brdict1, brdict2):
# Fail all collapse attempts
return False
rows = [
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, codebase='C'),
fakedb.Buildset(id=30, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.SourceStamp(id=235, codebase='C'),
fakedb.Buildset(id=31, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=235, buildsetid=31),
fakedb.SourceStamp(id=236, codebase='C'),
fakedb.Buildset(id=32, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=236, buildsetid=32),
fakedb.BuildRequest(id=19, buildsetid=30, builderid=77,
priority=13, submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=20, buildsetid=31, builderid=77,
priority=13, submitted_at=1300305712, results=-1),
fakedb.BuildRequest(id=21, buildsetid=32, builderid=77,
priority=13, submitted_at=1300305712, results=-1),
]
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
self.do_request_collapse(rows, [21], [])
def do_test_maybeBuildsetComplete(self,
buildRequestCompletions={},
buildRequestResults={},
buildsetComplete=False,
expectComplete=False,
expectMessage=False,
expectSuccess=True):
"""Test maybeBuildsetComplete.
@param buildRequestCompletions: dict mapping brid to True if complete,
else False (and defaulting to False)
@param buildRequestResults: dict mapping brid to result (defaulting
to SUCCESS)
@param buildsetComplete: true if the buildset is already complete
@param expectComplete: true if the buildset should be complete at exit
@param expectMessage: true if a buildset completion message is expected
@param expectSuccess: if expectComplete, whether to expect the buildset
to be complete
This first adds two buildsets to the database - 72 and 73. Buildset 72
is already complete if buildsetComplete is true; 73 is not complete.
It adds four buildrequests - 42, 43, and 44 for buildset 72, and 45 for
buildset 73. The completion and results are based on
buidlRequestCompletions and buildRequestResults.
Then, maybeBuildsetComplete is called for buildset 72, and the
expectations are checked.
"""
clock = task.Clock()
clock.advance(A_TIMESTAMP)
def mkbr(brid, bsid=72):
return fakedb.BuildRequest(id=brid, buildsetid=bsid,
complete=buildRequestCompletions.get(brid),
results=buildRequestResults.get(brid, SUCCESS))
yield self.master.db.insertTestData([
fakedb.Buildset(id=72,
submitted_at=EARLIER,
complete=buildsetComplete,
complete_at=A_TIMESTAMP if buildsetComplete else None),
mkbr(42), mkbr(43), mkbr(44),
fakedb.BuildsetSourceStamp(buildsetid=72, sourcestampid=234),
fakedb.Buildset(id=73,
complete=False),
mkbr(45, bsid=73),
fakedb.BuildsetSourceStamp(buildsetid=73, sourcestampid=234),
])
yield self.rtype.maybeBuildsetComplete(72, _reactor=clock)
self.master.db.buildsets.assertBuildsetCompletion(72, expectComplete)
if expectMessage:
self.assertEqual(self.master.mq.productions, [
self._buildsetCompleteMessage(72,
results=SUCCESS if expectSuccess else FAILURE,
submitted_at=EARLIER_EPOCH),
])
else:
self.assertEqual(self.master.mq.productions, [])
def test_canBeCollapsed_different_codebases_raises_error(self):
""" This testcase has two buildrequests
Request Change Codebase Revision Comment
----------------------------------------------------------------------
288 17 C 1800 request 1 has repo not in request 2
289 18 D 2100 request 2 has repo not in request 1
--------------------------------
Merge cannot be performed and raises error:
Merging requests requires both requests to have the same codebases
"""
brDicts = [] # list of buildrequests dictionary
master = fakemaster.make_master(testcase=self,
wantData=True,
wantDb=True)
master.db.insertTestData([
fakedb.Builder(id=77, name='bldr'),
fakedb.SourceStamp(id=238,
branch='trunk',
revision='1800',
repository='svn://c..',
codebase='C',
project='world-domination'),
fakedb.Change(changeid=17,
branch='trunk',
revision='1800',
repository='svn://c..',
codebase='C',
project='world-domination',
sourcestampid=238),
fakedb.SourceStamp(id=239,
branch='trunk',
revision='2100',
repository='svn://d..',
codebase='D',
project='world-domination'),
fakedb.Change(changeid=18,
branch='trunk',
revision='2100',
repository='svn://d..',
codebase='D',
project='world-domination',
sourcestampid=239),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=238),
fakedb.BuildRequest(id=288, buildsetid=539, builderid=77),
fakedb.Buildset(id=540, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=540, sourcestampid=239),
fakedb.BuildRequest(id=289, buildsetid=540, builderid=77),
])
# use getBuildRequest to minimize the risk from changes to the format
# of the brdict
req = yield master.db.buildrequests.getBuildRequest(288)
brDicts.append(req)
req = yield master.db.buildrequests.getBuildRequest(289)
brDicts.append(req)
can_collapse = \
yield buildrequest.BuildRequest.canBeCollapsed(master, brDicts[0],
brDicts[1])
self.assertEqual(can_collapse, False)
def insert_test_getRecentBuildsets_data(self):
return self.insertTestData([
fakedb.SourceStamp(id=91, branch='branch_a', repository='repo_a'),
fakedb.Buildset(id=91,
complete=0,
complete_at=298297875,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn1'),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=91),
fakedb.Buildset(id=92,
complete=1,
complete_at=298297876,
results=7,
submitted_at=266761876,
external_idstring='extid',
reason='rsn2'),
fakedb.BuildsetSourceStamp(buildsetid=92, sourcestampid=91),
# buildset unrelated to the change
fakedb.Buildset(id=93,
complete=1,
complete_at=298297877,
results=7,
submitted_at=266761877,
external_idstring='extid',
reason='rsn2'),
])
def do_test_getBuildRequests_branch_arg(self, **kwargs):
expected = kwargs.pop('expected')
d = self.insertTestData([
fakedb.Buildset(id=self.BSID + 1),
fakedb.BuildRequest(
id=70, buildsetid=self.BSID + 1, builderid=self.BLDRID1),
fakedb.SourceStamp(id=self.BSID + 1,
branch='branch_A'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 1,
sourcestampid=self.BSID + 1),
fakedb.Buildset(id=self.BSID + 2),
fakedb.BuildRequest(
id=80, buildsetid=self.BSID + 2, builderid=self.BLDRID1),
fakedb.SourceStamp(id=self.BSID + 2,
repository='repository_A'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 2,
sourcestampid=self.BSID + 2),
fakedb.Buildset(id=self.BSID + 3),
fakedb.BuildRequest(
id=90, buildsetid=self.BSID + 3, builderid=self.BLDRID1),
fakedb.SourceStamp(id=self.BSID + 3,
branch='branch_A', repository='repository_A'),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID + 3,
sourcestampid=self.BSID + 3),
])
d.addCallback(lambda _:
self.db.buildrequests.getBuildRequests(**kwargs))
@d.addCallback
def check(brlist):
self.assertEqual(sorted([br['buildrequestid'] for br in brlist]),
sorted(expected))
return d
def test_collapseRequests_collapse_default(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, codebase='C'),
fakedb.Buildset(id=30,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.SourceStamp(id=235, codebase='C'),
fakedb.Buildset(id=31,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=235, buildsetid=31),
fakedb.SourceStamp(id=236, codebase='C'),
fakedb.SourceStamp(id=237, codebase='A'),
fakedb.Buildset(id=32,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=236, buildsetid=32),
fakedb.Buildset(id=33,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=237, buildsetid=33),
fakedb.BuildRequest(id=19,
buildsetid=30,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
fakedb.BuildRequest(id=20,
buildsetid=31,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
fakedb.BuildRequest(id=21,
buildsetid=32,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
fakedb.BuildRequest(id=22,
buildsetid=33,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
]
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [19, 20])
def test_mergeRequests_no_merging(self):
""" Test if builder test for codebases in requests """
self.bldr.config.nextSlave = nth_slave(0)
# set up all of the data required for a BuildRequest object
rows = [
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, codebase='C'),
fakedb.Buildset(id=30,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.SourceStamp(id=235, codebase='C'),
fakedb.Buildset(id=31,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=235, buildsetid=31),
fakedb.SourceStamp(id=236, codebase='C'),
fakedb.Buildset(id=32,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=236, buildsetid=32),
fakedb.BuildRequest(id=19,
buildsetid=30,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
fakedb.BuildRequest(id=20,
buildsetid=31,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
fakedb.BuildRequest(id=21,
buildsetid=32,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
]
self.addSlaves({'test-slave1': 1, 'test-slave2': 1})
def mergeRequests_fn(builder, breq, other):
# Fail all merge attempts
return False
self.bldr.getMergeRequestsFn = lambda: mergeRequests_fn
# check if all are merged
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows,
exp_claims=[19, 20],
exp_builds=[
('test-slave1', [19]),
('test-slave2', [20]),
])
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.SourceStamp(id=92),
fakedb.Buildset(id=13, complete=True),
fakedb.Buildset(id=14, complete=False),
fakedb.BuildsetSourceStamp(buildsetid=13, sourcestampid=92),
fakedb.BuildsetSourceStamp(buildsetid=14, sourcestampid=92),
])
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Buildset(id=13, reason='because I said so'),
fakedb.SourceStamp(id=92),
fakedb.SourceStamp(id=93),
fakedb.BuildsetSourceStamp(buildsetid=13, sourcestampid=92),
fakedb.BuildsetSourceStamp(buildsetid=13, sourcestampid=93),
fakedb.Buildset(id=14, reason='no sourcestamps'),
])
def insert_test_getBuildsets_data(self):
return self.insertTestData([
fakedb.Buildset(id=91, complete=0,
complete_at=298297875, results=-1, submitted_at=266761875,
external_idstring='extid', reason='rsn1'),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
fakedb.Buildset(id=92, complete=1,
complete_at=298297876, results=7, submitted_at=266761876,
external_idstring='extid', reason='rsn2'),
fakedb.BuildsetSourceStamp(buildsetid=92, sourcestampid=234),
])
def setUp(self):
self.setUpTestReactor()
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(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()
# 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 test_mergeRequest_no_other_request(self):
""" Test if builder test for codebases in requests """
self.bldr.config.nextSlave = nth_slave(0)
# set up all of the data required for a BuildRequest object
rows = [
fakedb.SourceStamp(id=234, codebase='A'),
fakedb.Change(changeid=14, codebase='A', sourcestampid=234),
fakedb.Buildset(id=30,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildRequest(id=19,
buildsetid=30,
buildername='A',
priority=13,
submitted_at=1300305712,
results=-1),
]
self.addSlaves({'test-slave1': 1, 'test-slave2': 1})
def mergeRequests_fn(builder, breq, other):
# Allow all requests
self.fail("Should never be called")
return True
self.bldr.getMergeRequestsFn = lambda: mergeRequests_fn
# check if the request remains the same
yield self.do_test_maybeStartBuildsOnBuilder(rows=rows,
exp_claims=[19],
exp_builds=[
('test-slave1', [19]),
])
def test_getBuildset_incomplete_zero(self):
yield self.insertTestData([
fakedb.Buildset(id=91,
complete=0,
complete_at=0,
results=-1,
submitted_at=266761875,
external_idstring='extid',
reason='rsn'),
fakedb.BuildsetSourceStamp(buildsetid=91, sourcestampid=234),
])
bsdict = yield self.db.buildsets.getBuildset(91)
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=False,
complete_at=None,
results=-1,
bsid=91,
parent_buildid=None,
parent_relationship=None))
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"),
])
for k, v in iteritems(self.TEST_PROPS):
self.db.insertTestData([
fakedb.BuildProperty(buildid=20 + i, name=k, value=v)
])
def test_getSourceStampsForBuild_OneCodeBase(self):
rows = [fakedb.Master(id=88, name="bar"),
fakedb.Worker(id=13, name='one'),
fakedb.Builder(id=77, name='A'),
fakedb.SourceStamp(id=234, codebase='A', created_at=CREATED_AT,
revision="aaa"),
# fakedb.Change(changeid=14, codebase='A', sourcestampid=234),
fakedb.Buildset(id=30, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=234, buildsetid=30),
fakedb.BuildRequest(id=19, buildsetid=30, builderid=77,
priority=13, submitted_at=1300305712, results=-1),
fakedb.Build(id=50, buildrequestid=19, number=5, masterid=88,
builderid=77, state_string="test", workerid=13,
started_at=1304262222), ]
expected = [{
'branch': u'master',
'codebase': u'A',
'created_at': epoch2datetime(CREATED_AT),
'patch_author': None,
'patch_body': None,
'patch_comment': None,
'patch_level': None,
'patch_subdir': None,
'patchid': None,
'project': u'proj',
'repository': u'repo',
'revision': u'aaa',
'ssid': 234}]
return self.do_test_getSourceStampsForBuild(rows, 50, expected)
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 in iteritems(codebase_ss):
lastID["buildsetSourceStampid"] += 1
buildRows.append(
fakedb.BuildsetSourceStamp(id=lastID["buildsetSourceStampid"],
sourcestampid=ss,
buildsetid=lastID["buildsetid"]))
codebase_ss.clear()
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",
workerid=13,
started_at=SOMETIME + lastID["buildid"],
complete_at=SOMETIME + 2 * lastID["buildid"],
results=results)])
return buildRows
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, lambda b1, b2: cmp(b1.name, b2.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.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):
# a collection of rows that would otherwise clutter up every test
self.base_rows = [
fakedb.SourceStamp(id=21),
fakedb.Buildset(id=11, reason='because'),
fakedb.BuildsetSourceStamp(buildsetid=11, sourcestampid=21),
]
def setUp(self):
# 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.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,
masterid=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,
masterid=master_id,
claimed_at=2501),
]
def do_test_nextWorker(self, nextWorker, exp_choice=None):
builder_config = config.BuilderConfig(name='bldrconf',
workernames=['wk1', 'wk2'],
builddir='bdir',
factory=factory.BuildFactory(),
nextWorker=nextWorker)
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 setUp(self):
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_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 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
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_slaves(self, slave_count):
rows = self.base_rows[:]
for i in range(slave_count):
self.addSlaves({'test-slave%d' % i: 1})
rows.append(fakedb.Buildset(id=100 + i, reason='because'))
rows.append(fakedb.BuildsetSourceStamp(buildsetid=100 + i, sourcestampid=21))
rows.append(fakedb.BuildRequest(id=10 + i, buildsetid=100 + i, builderid=77))
return rows
def do_test(self, scheduler_name, expect_subscription,
results, expect_buildset):
"""Test the dependent scheduler by faking a buildset and subsequent
completion from an upstream scheduler.
@param scheduler_name: upstream scheduler's name
@param expect_subscription: whether to expect the dependent to
subscribe to the buildset
@param results: results of the upstream scheduler's buildset
@param expect_buidlset: whether to expect the dependent to generate
a new buildset in response
"""
sched = self.makeScheduler()
sched.activate()
# announce a buildset with a matching name..
self.db.insertTestData([
fakedb.SourceStamp(id=93, revision='555',
branch='master', project='proj', repository='repo',
codebase='cb'),
fakedb.Buildset(
id=44,
submitted_at=SUBMITTED_AT_TIME,
complete=False,
complete_at=None,
external_idstring=None,
reason=u'Because',
results=-1,
),
fakedb.BuildsetSourceStamp(buildsetid=44, sourcestampid=93),
])
self.sendBuildsetMessage(scheduler_name=scheduler_name, complete=False)
# 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=results)
self.sendBuildsetMessage(results=results, complete=True)
# and check whether a buildset was added in response
if expect_buildset:
self.assertEqual(self.addBuildsetCalls, [
('addBuildsetForSourceStamps', dict(
builderNames=None, # defaults
external_idstring=None,
properties=None,
reason=u'downstream',
sourcestamps=[93])),
])
else:
self.assertEqual(self.addBuildsetCalls, [])
def insertData(self):
self.db.insertTestData([
fakedb.SourceStamp(id=13, branch=u'secret'),
fakedb.Build(
id=15, buildrequestid=16, masterid=1, workerid=2, builderid=21),
fakedb.BuildRequest(id=16, buildsetid=17),
fakedb.Buildset(id=17),
fakedb.BuildsetSourceStamp(id=20, buildsetid=17, sourcestampid=13),
fakedb.Builder(id=21, name="builder"),
])
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 setupDb(self):
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Buildset(id=98, results=SUCCESS, reason="testReason1"),
fakedb.Builder(id=80, name='Builder1'),
fakedb.BuildRequest(id=9, buildsetid=97, builderid=80),
fakedb.BuildRequest(id=10, buildsetid=97, builderid=80),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=80),
fakedb.BuildRequest(id=12, buildsetid=98, builderid=80),
fakedb.Build(id=18, number=0, builderid=80, buildrequestid=9, workerid=13,
masterid=92, results=FAILURE),
fakedb.Build(id=19, number=1, builderid=80, buildrequestid=10, workerid=13,
masterid=92, results=RETRY),
fakedb.Build(id=20, number=2, builderid=80, buildrequestid=11, workerid=13,
masterid=92, results=SUCCESS),
fakedb.Build(id=21, number=3, builderid=80, buildrequestid=12, workerid=13,
masterid=92, results=SUCCESS),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(id=234),
fakedb.Change(changeid=13, branch=u'trunk', revision=u'9283', author='me@foo',
repository=u'svn://...', codebase=u'cbsvn',
project=u'world-domination', sourcestampid=234),
fakedb.Patch(id=99, patch_base64='aGVsbG8sIHdvcmxk',
patch_author='him@foo', patch_comment='foo', subdir='/foo',
patchlevel=3),
fakedb.SourceStamp(id=235, patchid=99),
])
for _id in (20, 21):
self.db.insertTestData([
fakedb.BuildProperty(
buildid=_id, name="workername", value="wrk"),
fakedb.BuildProperty(
buildid=_id, name="reason", value="because"),
fakedb.BuildProperty(
buildid=_id, name="owner", value="him"),
fakedb.Step(id=100 + _id, buildid=_id, name="step1"),
fakedb.Step(id=200 + _id, buildid=_id, name="step2"),
fakedb.Log(id=60 + _id, stepid=100 + _id, name='stdio', slug='stdio', type='s',
num_lines=2),
fakedb.LogChunk(logid=60 + _id, first_line=0, last_line=1, compressed=0,
content=self.LOGCONTENT),
])
@defer.inlineCallbacks
def getChangesForBuild(buildid):
assert buildid == 20
ch = yield self.master.db.changes.getChange(13)
defer.returnValue([ch])
self.master.db.changes.getChangesForBuild = getChangesForBuild
def setupBuildResults(self, results, wantPreviousBuild=False):
# this testsuite always goes through setupBuildResults so that
# the data is sure to be the real data schema known coming from data
# api
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Buildset(id=98, results=results, reason="testReason1"),
fakedb.Builder(id=80, name='Builder1'),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=80),
fakedb.Build(id=20, number=0, builderid=80, buildrequestid=11, workerid=13,
masterid=92, results=results),
fakedb.Step(id=50, buildid=20, number=5, name='make'),
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(id=234, patchid=99),
fakedb.Change(changeid=13, branch=u'trunk', revision=u'9283', author='me@foo',
repository=u'svn://...', codebase=u'cbsvn',
project=u'world-domination', sourcestampid=234),
fakedb.Log(id=60, stepid=50, name='stdio', slug='stdio', type='s',
num_lines=7),
fakedb.LogChunk(logid=60, first_line=0, last_line=1, compressed=0,
content=u'Unicode log with non-ascii (\u00E5\u00E4\u00F6).'),
fakedb.Patch(id=99, patch_base64='aGVsbG8sIHdvcmxk',
patch_author='him@foo', patch_comment='foo', subdir='/foo',
patchlevel=3),
])
for _id in (20,):
self.db.insertTestData([
fakedb.BuildProperty(
buildid=_id, name="workername", value="wrk"),
fakedb.BuildProperty(
buildid=_id, name="reason", value="because"),
fakedb.BuildProperty(
buildid=_id, name="scheduler", value="checkin"),
fakedb.BuildProperty(
buildid=_id, name="branch", value="master"),
])
res = yield utils.getDetailsForBuildset(self.master, 98, wantProperties=True,
wantPreviousBuild=wantPreviousBuild)
builds = res['builds']
buildset = res['buildset']
@defer.inlineCallbacks
def getChangesForBuild(buildid):
assert buildid == 20
ch = yield self.master.db.changes.getChange(13)
defer.returnValue([ch])
self.master.db.changes.getChangesForBuild = getChangesForBuild
defer.returnValue((buildset, builds))
def setUpTests(self):
# set up a sourcestamp and buildset for use below
self.MASTER_ID = fakedb.FakeBuildRequestsComponent.MASTER_ID
self.OTHER_MASTER_ID = self.MASTER_ID + 1111
self.db.master.masterid = self.MASTER_ID
return self.insertTestData([
fakedb.SourceStamp(id=234),
fakedb.Master(id=self.MASTER_ID, name="fake master"),
fakedb.Master(id=self.OTHER_MASTER_ID, name="other"),
fakedb.Buildset(id=self.BSID),
fakedb.BuildsetSourceStamp(buildsetid=self.BSID,
sourcestampid=234),
])