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.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 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'),
])
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 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_brdictToBuildRequest(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),
]))
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_cancelBuildRequest(self):
master = fakemaster.make_master()
master.db = fakedb.FakeDBConnector(self)
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(brdict):
self.assertEqual(brdict['results'], CANCELED)
self.assertEqual(brdict['complete'], 1)
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
d.addCallback(lambda br: br.cancelBuildRequest())
d.addCallback(lambda _: master.db.buildrequests.getBuildRequest(1))
d.addCallback(checkCanceled)
return d
def setupProject(self, builders):
self.master.botmaster.builderNames = builders.keys()
for bn, project in builders.items():
self.master.botmaster.builders[bn] = mockBuilder(
self.master, self.master_status, bn, project)
row = [
fakedb.BuildRequest(id=1,
buildsetid=1,
buildername='builder-02',
priority=20,
submitted_at=1450171024),
fakedb.SourceStampSet(id=1),
fakedb.Buildset(id=1, sourcestampsetid=1),
fakedb.SourceStamp(id=1,
revision='az',
codebase='cb',
sourcestampsetid=1,
branch='master',
repository='z')
]
yield self.master.db.insertTestData(row)
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77),
fakedb.Worker(id=13, name='sl'),
fakedb.Master(id=88),
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', slug='stdio', type='s',
num_lines=7),
fakedb.LogChunk(logid=60, first_line=0, last_line=1, compressed=0,
content=textwrap.dedent("""\
line zero
line 1""")),
fakedb.LogChunk(logid=60, first_line=2, last_line=4, compressed=0,
content=textwrap.dedent("""\
line TWO
line 3
line 2**2""")),
fakedb.LogChunk(logid=60, first_line=5, last_line=5, compressed=0,
content="another line"),
fakedb.LogChunk(logid=60, first_line=6, last_line=6, compressed=0,
content="yet another line"),
fakedb.Log(id=61, stepid=50, name='errors', slug='errors',
type='t', num_lines=100),
] + [
fakedb.LogChunk(logid=61, first_line=i, last_line=i, compressed=0,
content="%08d" % i)
for i in range(100)
] + [
fakedb.Log(id=62, stepid=50, name='notes', slug='notes', type='t',
num_lines=0),
# logid 62 is empty
])
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77, name='builder77'),
fakedb.Builder(id=78, name='builder78'),
fakedb.Builder(id=79, name='builder79'),
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.Build(id=14,
builderid=77,
masterid=88,
workerid=13,
buildrequestid=82,
number=4),
fakedb.Build(id=15,
builderid=78,
masterid=88,
workerid=12,
buildrequestid=83,
number=5,
complete_at=1),
fakedb.Build(id=16,
builderid=79,
masterid=88,
workerid=12,
buildrequestid=84,
number=6,
complete_at=1),
])
def test_download_artifact_fromchildren_windows(self):
br2 = fakedb.BuildRequest(id=2,
buildsetid=2,
buildername="B",
triggeredbybrid=1)
self.setupStep(artifact.DownloadArtifactsFromChildren(
workdir='build',
artifactServer='*****@*****.**',
artifactServerDir='/artifacts',
artifactServerPort=22,
artifactDirectory='mydir',
artifactBuilderName='B',
artifactDestination='./base/local'), [br2],
winslave=True)
expectedRemote = '\'[email protected]:/artifacts/B/2_01_01_1970_00_00_00_+0000/mydir/\''
expectedLocal = './base/local/2'
expectedLocalMkDirPath = r'base\local\2'
self.expectCommands(
ExpectShell(workdir='build',
usePTY='slave-config',
command=['mkdir', expectedLocalMkDirPath]) + 0,
ExpectShell(
workdir='build',
usePTY='slave-config',
command=
'powershell.exe -C for ($i=1; $i -le 5; $i++) { rsync -var --progress --partial '
+ expectedRemote + " '" + expectedLocal + "'" +
' --rsh=\'ssh -p 22\'; if ($?) { exit 0 } else { sleep 5} } exit -1'
) + 0 + ExpectShell.log('stdio', stdout=''))
self.expectOutcome(
result=SUCCESS,
status_text=['Downloaded artifacts from 1 partitions'])
return self.runStep()
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_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
brdict = yield master.db.buildrequests.getBuildRequest(288)
br = yield buildrequest.BuildRequest.fromBrdict(master, brdict)
# check enough of the source stamp to verify it found the changes
self.assertEqual([ss.ssid for ss in br.sources.values()], [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)
def makeBuildRequestRows(self, brid, bsid, changeid, ssid, codebase, branch=None,
project=None, repository=None, patchid=None, revision=None):
rows = [
fakedb.SourceStamp(id=ssid, codebase=codebase, branch=branch,
project=project, repository=repository, patchid=patchid, revision=revision),
fakedb.Buildset(id=bsid, reason='foo',
submitted_at=1300305712, results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=ssid, buildsetid=bsid),
fakedb.BuildRequest(id=brid, buildsetid=bsid, builderid=77,
priority=13, submitted_at=1300305712, results=-1),
]
if changeid:
rows.append(
fakedb.Change(changeid=changeid, branch='trunk', revision='9283',
repository='svn://...', project='world-domination',
sourcestampid=ssid)
)
if patchid:
rows.append(
fakedb.Patch(id=patchid, patch_base64='aGVsbG8sIHdvcmxk',
patch_author='bar', patch_comment='foo', subdir='/foo',
patchlevel=3))
return rows
def test_getBuildRequest(self):
d = self.insertTestData([
fakedb.BuildRequest(id=44, buildsetid=self.BSID, builderid=self.BLDRID1,
complete=1, results=75, priority=7,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.BuildRequestClaim(
brid=44, masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
])
d.addCallback(lambda _:
self.db.buildrequests.getBuildRequest(44))
@d.addCallback
def check(brdict):
self.assertEqual(brdict,
dict(buildrequestid=44, buildsetid=self.BSID,
builderid=self.BLDRID1, buildername="builder1",
priority=7, claimed=True,
claimed_by_masterid=self.MASTER_ID, complete=True,
results=75, claimed_at=self.CLAIMED_AT,
submitted_at=self.SUBMITTED_AT,
complete_at=self.COMPLETE_AT, waited_for=False))
return d
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.Builder(id=77, name='A'),
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,
builderid=77,
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_collapseRequests_no_other_request(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# Allow all requests
self.fail("Should never be called")
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
rows = [
fakedb.Builder(id=77, name='A'),
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,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
]
return self.do_request_collapse(rows, [19], [])
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 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
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: buildrequest.BuildRequest.fromBrdict(
master, brdict))
def check(br):
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 do_test_unclaimMethod(self, method, expected):
d = self.insertTestData([
# 44: a complete build (should not be unclaimed)
fakedb.BuildRequest(id=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.BuildRequestClaim(brid=44,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 45: incomplete build belonging to this incarnation
fakedb.BuildRequest(id=45,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
complete_at=0),
fakedb.BuildRequestClaim(brid=45,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 46: incomplete build belonging to another master
fakedb.BuildRequest(id=46,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
complete_at=0),
fakedb.BuildRequestClaim(brid=46,
masterid=self.OTHER_MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 47: unclaimed
fakedb.BuildRequest(id=47,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
complete_at=0),
# 48: claimed by this master, but recently
fakedb.BuildRequest(id=48,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
complete_at=0),
fakedb.BuildRequestClaim(brid=48,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH - 50),
# 49: incomplete old build belonging to another master
fakedb.BuildRequest(id=49,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
complete_at=0),
fakedb.BuildRequestClaim(brid=49,
masterid=self.OTHER_MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH - 1000),
])
d.addCallback(lambda _: method())
# just select the unclaimed requests
d.addCallback(
lambda _: self.db.buildrequests.getBuildRequests(claimed=False))
@d.addCallback
def check(results):
self.assertEqual(sorted([r['buildrequestid'] for r in results]),
sorted(expected))
return d
def test_getBuildRequests_combo(self):
d = self.insertTestData([
# 44: everything we want
fakedb.BuildRequest(id=44,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.BuildRequestClaim(brid=44,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 45: different builderid
fakedb.BuildRequest(id=45,
buildsetid=self.BSID,
builderid=self.BLDRID2,
complete=1,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.BuildRequestClaim(brid=45,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 46: incomplete
fakedb.BuildRequest(id=46,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=0,
results=92,
complete_at=0),
fakedb.BuildRequestClaim(brid=46,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 47: unclaimed
fakedb.BuildRequest(id=47,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH),
# 48: claimed by other
fakedb.BuildRequest(id=48,
buildsetid=self.BSID,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.BuildRequestClaim(brid=48,
masterid=self.OTHER_MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
# 49: different bsid
fakedb.Buildset(id=self.BSID + 1),
fakedb.BuildRequest(id=49,
buildsetid=self.BSID + 1,
builderid=self.BLDRID1,
complete=1,
results=92,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.BuildRequestClaim(brid=49,
masterid=self.MASTER_ID,
claimed_at=self.CLAIMED_AT_EPOCH),
])
d.addCallback(lambda _: self.db.buildrequests.getBuildRequests(
builderid=self.BLDRID1,
claimed=self.MASTER_ID,
complete=True,
bsid=self.BSID))
@d.addCallback
def check(brlist):
self.assertEqual([br['buildrequestid'] for br in brlist], [44])
return d
class Tests(interfaces.InterfaceTests):
backgroundData = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Build(id=30,
buildrequestid=41,
number=7,
masterid=88,
builderid=88,
workerid=47),
fakedb.Step(id=101, buildid=30, number=1, name='one'),
fakedb.Step(id=102, buildid=30, number=2, name='two'),
]
testLogLines = [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=7,
type=u's'),
fakedb.LogChunk(logid=201,
first_line=0,
last_line=1,
compressed=0,
content=textwrap.dedent("""\
line zero
line 1""" + "x" * 200)),
fakedb.LogChunk(logid=201,
first_line=2,
last_line=4,
compressed=0,
content=textwrap.dedent("""\
line TWO
line 2**2""")),
fakedb.LogChunk(logid=201,
first_line=5,
last_line=5,
compressed=0,
content="another line"),
fakedb.LogChunk(logid=201,
first_line=6,
last_line=6,
compressed=0,
content="yet another line"),
]
bug3101Content = base64.b64decode("""
PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0
9PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpbU0tJUFBFRF0Kbm90IGEgd2luMz
IgcGxhdGZvcm0KCmJ1aWxkc2xhdmUudGVzdC51bml0LnRlc3RfcnVucHJvY2Vzcy5UZ
XN0UnVuUHJvY2Vzcy50ZXN0UGlwZVN0cmluZwotLS0tLS0tLS0tLS0tLS0tLS0tLS0t
LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0
tLS0tLS0tClJhbiAyNjcgdGVzdHMgaW4gNS4zNzhzCgpQQVNTRUQgKHNraXBzPTEsIH
N1Y2Nlc3Nlcz0yNjYpCnByb2dyYW0gZmluaXNoZWQgd2l0aCBleGl0IGNvZGUgMAplb
GFwc2VkVGltZT04LjI0NTcwMg==""")
bug3101Rows = [
fakedb.Log(id=1470,
stepid=101,
name=u'problems',
slug=u'problems',
complete=1,
num_lines=11,
type=u't'),
fakedb.LogChunk(logid=1470,
first_line=0,
last_line=10,
compressed=0,
content=bug3101Content),
]
@defer.inlineCallbacks
def checkTestLogLines(self):
expLines = [
'line zero', 'line 1' + "x" * 200, 'line TWO', '', 'line 2**2',
'another line', 'yet another line'
]
for first_line in range(0, 7):
for last_line in range(first_line, 7):
got_lines = yield self.db.logs.getLogLines(
201, first_line, last_line)
self.assertEqual(
got_lines,
"\n".join(expLines[first_line:last_line + 1] + [""]))
# check overflow
self.assertEqual((yield self.db.logs.getLogLines(201, 5, 20)),
"\n".join(expLines[5:7] + [""]))
# signature tests
def test_signature_getLog(self):
@self.assertArgSpecMatches(self.db.logs.getLog)
def getLog(self, logid):
pass
def test_signature_getLogBySlug(self):
@self.assertArgSpecMatches(self.db.logs.getLogBySlug)
def getLogBySlug(self, stepid, slug):
pass
def test_signature_getLogs(self):
@self.assertArgSpecMatches(self.db.logs.getLogs)
def getLogs(self, stepid=None):
pass
def test_signature_getLogLines(self):
@self.assertArgSpecMatches(self.db.logs.getLogLines)
def getLogLines(self, logid, first_line, last_line):
pass
def test_signature_addLog(self):
@self.assertArgSpecMatches(self.db.logs.addLog)
def addLog(self, stepid, name, slug, type):
pass
def test_signature_appendLog(self):
@self.assertArgSpecMatches(self.db.logs.appendLog)
def appendLog(self, logid, content):
pass
def test_signature_finishLog(self):
@self.assertArgSpecMatches(self.db.logs.finishLog)
def finishLog(self, logid):
pass
def test_signature_compressLog(self):
@self.assertArgSpecMatches(self.db.logs.compressLog)
def compressLog(self, logid, force=False):
pass
# method tests
@defer.inlineCallbacks
def test_getLog(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
])
logdict = yield self.db.logs.getLog(201)
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(
logdict, {
'id': 201,
'stepid': 101,
'name': u'stdio',
'slug': u'stdio',
'complete': False,
'num_lines': 200,
'type': 's',
})
@defer.inlineCallbacks
def test_getLog_missing(self):
logdict = yield self.db.logs.getLog(201)
self.assertEqual(logdict, None)
@defer.inlineCallbacks
def test_getLogBySlug(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
fakedb.Log(id=202,
stepid=101,
name=u'dbg.log',
slug=u'dbg_log',
complete=1,
num_lines=200,
type=u's'),
])
logdict = yield self.db.logs.getLogBySlug(101, u'dbg_log')
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(logdict['id'], 202)
@defer.inlineCallbacks
def test_getLogBySlug_missing(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
])
logdict = yield self.db.logs.getLogBySlug(102, u'stdio')
self.assertEqual(logdict, None)
@defer.inlineCallbacks
def test_getLogs(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
fakedb.Log(id=202,
stepid=101,
name=u'dbg.log',
slug=u'dbg_log',
complete=1,
num_lines=300,
type=u't'),
fakedb.Log(id=203,
stepid=102,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
])
logdicts = yield self.db.logs.getLogs(101)
for logdict in logdicts:
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(sorted([ld['id'] for ld in logdicts]), [201, 202])
@defer.inlineCallbacks
def test_getLogLines(self):
yield self.insertTestData(self.backgroundData + self.testLogLines)
yield self.checkTestLogLines()
# check line number reversal
self.assertEqual((yield self.db.logs.getLogLines(201, 6, 3)), '')
@defer.inlineCallbacks
def test_getLogLines_empty(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name=u'stdio',
slug=u'stdio',
complete=0,
num_lines=200,
type=u's'),
])
self.assertEqual((yield self.db.logs.getLogLines(201, 9, 99)), '')
self.assertEqual((yield self.db.logs.getLogLines(999, 9, 99)), '')
@defer.inlineCallbacks
def test_getLogLines_bug3101(self):
# regression test for #3101
content = self.bug3101Content
yield self.insertTestData(self.backgroundData + self.bug3101Rows)
# overall content is the same, with '\n' padding at the end
expected = bytes2NativeString(self.bug3101Content + b'\n')
self.assertEqual((yield self.db.logs.getLogLines(1470, 0, 99)),
expected)
# try to fetch just one line
expected = bytes2NativeString(content.split(b'\n')[0] + b'\n')
self.assertEqual((yield self.db.logs.getLogLines(1470, 0, 0)),
expected)
@defer.inlineCallbacks
def test_addLog_getLog(self):
yield self.insertTestData(self.backgroundData)
logid = yield self.db.logs.addLog(stepid=101,
name=u'config.log',
slug=u'config_log',
type=u't')
logdict = yield self.db.logs.getLog(logid)
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(
logdict, {
'id': logid,
'stepid': 101,
'name': u'config.log',
'slug': u'config_log',
'complete': False,
'num_lines': 0,
'type': 't',
})
@defer.inlineCallbacks
def test_appendLog_getLogLines(self):
yield self.insertTestData(self.backgroundData + self.testLogLines)
logid = yield self.db.logs.addLog(stepid=102,
name=u'another',
slug=u'another',
type=u's')
self.assertEqual((yield self.db.logs.appendLog(logid, u'xyz\n')),
(0, 0))
self.assertEqual((yield self.db.logs.appendLog(201, u'abc\ndef\n')),
(7, 8))
self.assertEqual((yield self.db.logs.appendLog(logid, u'XYZ\n')),
(1, 1))
self.assertEqual((yield self.db.logs.getLogLines(201, 6, 7)),
u"yet another line\nabc\n")
self.assertEqual((yield self.db.logs.getLogLines(201, 7, 8)),
u"abc\ndef\n")
self.assertEqual((yield self.db.logs.getLogLines(201, 8, 8)), u"def\n")
self.assertEqual((yield self.db.logs.getLogLines(logid, 0, 1)),
u"xyz\nXYZ\n")
self.assertEqual(
(yield self.db.logs.getLog(logid)), {
'complete': False,
'id': logid,
'name': u'another',
'slug': u'another',
'num_lines': 2,
'stepid': 102,
'type': u's',
})
@defer.inlineCallbacks
def test_compressLog(self):
yield self.insertTestData(self.backgroundData + self.testLogLines)
yield self.db.logs.compressLog(201)
# test log lines should still be readable just the same
yield self.checkTestLogLines()
@defer.inlineCallbacks
def test_addLogLines_big_chunk(self):
yield self.insertTestData(self.backgroundData + self.testLogLines)
self.assertEqual(
(yield self.db.logs.appendLog(201, u'abc\n' * 20000)), # 80k
(7, 20006))
lines = yield self.db.logs.getLogLines(201, 7, 50000)
self.assertEqual(len(lines), 80000)
self.assertEqual(lines, (u'abc\n' * 20000))
@defer.inlineCallbacks
def test_addLogLines_big_chunk_big_lines(self):
yield self.insertTestData(self.backgroundData + self.testLogLines)
line = u'x' * 33000 + '\n'
self.assertEqual((yield self.db.logs.appendLog(201, line * 3)),
(7, 9)) # three long lines, all truncated
lines = yield self.db.logs.getLogLines(201, 7, 100)
self.assertEqual(len(lines), 99003)
self.assertEqual(lines, (line * 3))
def test_mergeSourceStampsWith_common_codebases(self):
""" This testcase has two buildrequests
Request Change Codebase Revision Comment
----------------------------------------------------------------------
288 13 A 9283
289 15 A 9284
288 14 B 9200
289 16 B 9201
--------------------------------
After merged in Build:
Source1 has rev 9284 and contains changes 13 and 15 from repository svn://a
Source2 has rev 9201 and contains changes 14 and 16 from repository svn://b
"""
brs = [] # list of buildrequests
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='9200', repository='svn://b..', codebase='B',
project='world-domination'),
fakedb.Change(changeid=14, branch='trunk', revision='9200',
repository='svn://b..', codebase='A',
project='world-domination', sourcestampid=235),
fakedb.SourceStamp(id=236, branch='trunk',
revision='9284', repository='svn://a..', codebase='A',
project='world-domination'),
fakedb.Change(changeid=15, branch='trunk', revision='9284',
repository='svn://a..', codebase='A',
project='world-domination', sourcestampid=236),
fakedb.SourceStamp(id=237, branch='trunk',
revision='9201', repository='svn://b..', codebase='B',
project='world-domination'),
fakedb.Change(changeid=16, branch='trunk', revision='9201',
repository='svn://b..', codebase='B',
project='world-domination', sourcestampid=237),
fakedb.Buildset(id=539, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=234),
fakedb.BuildsetSourceStamp(buildsetid=539, sourcestampid=235),
fakedb.BuildRequest(id=288, buildsetid=539, builderid=77),
fakedb.Buildset(id=540, reason='triggered'),
fakedb.BuildsetSourceStamp(buildsetid=540, sourcestampid=236),
fakedb.BuildsetSourceStamp(buildsetid=540, sourcestampid=237),
fakedb.BuildRequest(id=289, buildsetid=540, builderid=77),
])
# 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))
d.addCallback(lambda br: brs.append(br))
d.addCallback(lambda _:
master.db.buildrequests.getBuildRequest(289))
d.addCallback(lambda brdict:
buildrequest.BuildRequest.fromBrdict(master, brdict))
d.addCallback(lambda br: brs.append(br))
def check(_):
sources = brs[0].mergeSourceStampsWith(brs[1:])
source1 = source2 = None
for source in sources:
if source.codebase == 'A':
source1 = source
if source.codebase == 'B':
source2 = source
self.assertFalse(source1 is None)
self.assertEqual(source1.revision, '9284')
self.assertFalse(source2 is None)
self.assertEqual(source2.revision, '9201')
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='trunk',
revision='9283',
author='me@foo',
repository='svn://...',
codebase='cbsvn',
project='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)
return [ch]
self.master.db.changes.getChangesForBuild = getChangesForBuild
def test_getSourceStampsForBuild_3CodeBases(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.SourceStamp(id=235,
codebase='B',
created_at=CREATED_AT + 10,
revision="bbb"),
fakedb.SourceStamp(id=236,
codebase='C',
created_at=CREATED_AT + 20,
revision="ccc"),
# 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.BuildsetSourceStamp(sourcestampid=235, buildsetid=30),
fakedb.BuildsetSourceStamp(sourcestampid=236, 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
}, {
'branch': u'master',
'codebase': u'B',
'created_at': epoch2datetime(CREATED_AT + 10),
'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'bbb',
'ssid': 235
}, {
'branch': u'master',
'codebase': u'C',
'created_at': epoch2datetime(CREATED_AT + 20),
'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'ccc',
'ssid': 236
}]
return self.do_test_getSourceStampsForBuild(rows, 50, expected)
class TestBuildRequestCollapser(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
self.master = fakemaster.make_master(testcase=self,
wantData=True,
wantDb=True)
self.master.botmaster = mock.Mock(name='botmaster')
self.master.botmaster.builders = {}
self.builders = {}
self.bldr = yield self.createBuilder('A', builderid=77)
@defer.inlineCallbacks
def createBuilder(self, name, builderid=None):
if builderid is None:
b = fakedb.Builder(name=name)
yield self.master.db.insertTestData([b])
builderid = b.id
bldr = mock.Mock(name=name)
bldr.name = name
bldr.master = self.master
self.master.botmaster.builders[name] = bldr
self.builders[name] = bldr
bldr.getCollapseRequestsFn = lambda: False
defer.returnValue(bldr)
def tearDown(self):
pass
@defer.inlineCallbacks
def do_request_collapse(self, rows, brids, exp):
yield self.master.db.insertTestData(rows)
brCollapser = buildrequest.BuildRequestCollapser(self.master, brids)
self.assertEqual(exp, (yield brCollapser.collapse()))
def test_collapseRequests_no_other_request(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# Allow all requests
self.fail("Should never be called")
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
rows = [
fakedb.Builder(id=77, name='A'),
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,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
]
return self.do_request_collapse(rows, [19], [])
BASE_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),
]
def test_collapseRequests_no_collapse(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# Fail all collapse attempts
return False
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
return self.do_request_collapse(self.BASE_ROWS, [21], [])
def test_collapseRequests_collapse_all(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# collapse all attempts
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
return self.do_request_collapse(self.BASE_ROWS, [21], [19, 20])
def test_collapseRequests_collapse_all_duplicates(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
# collapse all attempts
return True
self.bldr.getCollapseRequestsFn = lambda: collapseRequests_fn
return self.do_request_collapse(self.BASE_ROWS, [21, 21], [19, 20])
# As documented:
# Sourcestamps are compatible if all of the below conditions are met:
#
# * Their codebase, branch, project, and repository attributes match exactly
# * Neither source stamp has a patch (e.g., from a try scheduler)
# * Either both source stamps are associated with changes, or neither are associated with changes but they have matching revisions.
def makeBuildRequestRows(self,
brid,
bsid,
changeid,
ssid,
codebase,
branch=None,
project=None,
repository=None,
patchid=None,
revision=None):
rows = [
fakedb.SourceStamp(id=ssid,
codebase=codebase,
branch=branch,
project=project,
repository=repository,
patchid=patchid,
revision=revision),
fakedb.Buildset(id=bsid,
reason='foo',
submitted_at=1300305712,
results=-1),
fakedb.BuildsetSourceStamp(sourcestampid=ssid, buildsetid=bsid),
fakedb.BuildRequest(id=brid,
buildsetid=bsid,
builderid=77,
priority=13,
submitted_at=1300305712,
results=-1),
]
if changeid:
rows.append(
fakedb.Change(changeid=changeid,
branch='trunk',
revision='9283',
repository='svn://...',
project='world-domination',
sourcestampid=ssid))
if patchid:
rows.append(
fakedb.Patch(id=patchid,
patch_base64='aGVsbG8sIHdvcmxk',
patch_author='bar',
patch_comment='foo',
subdir='/foo',
patchlevel=3))
return rows
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A')
rows += self.makeBuildRequestRows(21, 121, None, 221, 'C')
rows += self.makeBuildRequestRows(19, 119, None, 210, 'C')
rows += self.makeBuildRequestRows(20, 120, None, 220, 'C')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [19, 20])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases_branches(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A', 'br1')
rows += self.makeBuildRequestRows(21, 121, None, 221, 'C', 'br2')
rows += self.makeBuildRequestRows(19, 119, None, 210, 'C', 'br2')
rows += self.makeBuildRequestRows(20, 120, None, 220, 'C', 'br3')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [19])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases_repository(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A', None, 'p1')
rows += self.makeBuildRequestRows(21, 121, None, 221, 'C', None, 'p2')
rows += self.makeBuildRequestRows(19, 119, None, 210, 'C', None, 'p2')
rows += self.makeBuildRequestRows(20, 120, None, 220, 'C', None, 'p3')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [19])
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_codebases_projects(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A', None, None,
'project1')
rows += self.makeBuildRequestRows(21, 121, None, 221, 'C', None, None,
'project2')
rows += self.makeBuildRequestRows(19, 119, None, 210, 'C', None, None,
'project2')
rows += self.makeBuildRequestRows(20, 120, None, 220, 'C', None, None,
'project3')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [19])
# * Neither source stamp has a patch (e.g., from a try scheduler)
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_a_patch(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A')
rows += self.makeBuildRequestRows(21, 121, None, 221, 'C')
rows += self.makeBuildRequestRows(19, 119, None, 210, 'C', patchid=123)
rows += self.makeBuildRequestRows(20, 120, None, 220, 'C')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [20])
# * Either both source stamps are associated with changes..
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_changes(self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A')
rows += self.makeBuildRequestRows(21, 121, 123, 221, 'C')
rows += self.makeBuildRequestRows(19, 119, None, 210, 'C')
rows += self.makeBuildRequestRows(20, 120, 124, 220, 'C')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [20])
# * ... or neither are associated with changes but they have matching revisions.
@defer.inlineCallbacks
def test_collapseRequests_collapse_default_with_non_matching_revision(
self):
def collapseRequests_fn(master, builder, brdict1, brdict2):
return buildrequest.BuildRequest.canBeCollapsed(
builder.master, brdict1, brdict2)
rows = [
fakedb.Builder(id=77, name='A'),
]
rows += self.makeBuildRequestRows(22, 122, None, 222, 'A')
rows += self.makeBuildRequestRows(21, 121, None, 221, 'C')
rows += self.makeBuildRequestRows(19,
119,
None,
210,
'C',
revision='abcd1234')
rows += self.makeBuildRequestRows(20, 120, None, 220, 'C')
self.bldr.getCollapseRequestsFn = lambda: Builder._defaultCollapseRequestFn
yield self.do_request_collapse(rows, [22], [])
yield self.do_request_collapse(rows, [21], [20])
class TestBuildsConnectorComponent(connector_component.ConnectorComponentMixin,
unittest.TestCase):
SUBMITTED_AT_EPOCH = 298297875
COMPLETE_AT_EPOCH = 329920275
def setUp(self):
d = self.setUpConnectorComponent(table_names=[
'builds', 'buildrequests', 'buildsets', 'sourcestamps',
'sourcestampsets', 'patches'
])
def finish_setup(_):
self.db.builds = builds.BuildsConnectorComponent(self.db)
d.addCallback(finish_setup)
return d
def tearDown(self):
return self.tearDownConnectorComponent()
# common sample data
background_data = [
fakedb.SourceStampSet(id=27),
fakedb.SourceStamp(id=27, sourcestampsetid=27, revision='abcd'),
fakedb.Buildset(id=20, sourcestampsetid=27),
fakedb.Buildset(id=30, sourcestampsetid=27),
fakedb.BuildRequest(id=41, buildsetid=20, buildername='b1'),
fakedb.BuildRequest(id=42, buildsetid=30, buildername='b1'),
]
last_builds = [
fakedb.BuildRequest(id=1,
buildsetid=1,
buildername="builder",
complete=1,
results=0,
submitted_at=SUBMITTED_AT_EPOCH,
complete_at=COMPLETE_AT_EPOCH),
fakedb.Buildset(id=1, sourcestampsetid=1),
fakedb.SourceStampSet(id=1),
fakedb.SourceStamp(id=1,
revision='a',
codebase='1',
sourcestampsetid=1,
branch='master',
repository='z'),
fakedb.SourceStamp(id=2,
revision='b',
codebase='2',
sourcestampsetid=1,
branch='staging',
repository='w'),
fakedb.Build(id=1,
number=4,
brid=1,
start_time=SUBMITTED_AT_EPOCH,
finish_time=COMPLETE_AT_EPOCH,
slavename='slave-01')
]
# tests
def test_getBuild(self):
d = self.insertTestData(self.background_data + [
fakedb.Build(id=50, brid=42, number=5, start_time=1304262222),
])
d.addCallback(lambda _: self.db.builds.getBuild(50))
def check(bdict):
self.assertEqual(
bdict,
dict(bid=50,
number=5,
brid=42,
start_time=epoch2datetime(1304262222),
finish_time=None))
d.addCallback(check)
return d
def test_getBuild_missing(self):
d = defer.succeed(None)
d.addCallback(lambda _: self.db.builds.getBuild(50))
def check(bdict):
self.assertEqual(bdict, None)
d.addCallback(check)
return d
def test_getBuildsForRequest(self):
d = self.insertTestData(self.background_data + [
fakedb.Build(id=50, brid=42, number=5, start_time=1304262222),
fakedb.Build(id=51, brid=41, number=6, start_time=1304262223),
fakedb.Build(id=52,
brid=42,
number=7,
start_time=1304262224,
finish_time=1304262235),
])
d.addCallback(lambda _: self.db.builds.getBuildsForRequest(42))
def check(bdicts):
self.assertEqual(
sorted(bdicts),
sorted([
dict(bid=50,
number=5,
brid=42,
start_time=epoch2datetime(1304262222),
finish_time=None),
dict(bid=52,
number=7,
brid=42,
start_time=epoch2datetime(1304262224),
finish_time=epoch2datetime(1304262235)),
]))
d.addCallback(check)
return d
def test_addBuild(self):
clock = task.Clock()
clock.advance(1302222222)
d = self.insertTestData(self.background_data)
d.addCallback(lambda _: self.db.builds.addBuild(
brid=41, number=119, slavename="slave-01", _reactor=clock))
def check(_):
def thd(conn):
r = conn.execute(self.db.model.builds.select())
rows = [(row.brid, row.number, row.start_time, row.finish_time)
for row in r.fetchall()]
self.assertEqual(rows, [(41, 119, 1302222222, None)])
return self.db.pool.do(thd)
d.addCallback(check)
return d
def test_finishBuilds(self):
clock = task.Clock()
clock.advance(1305555555)
d = self.insertTestData(self.background_data + [
fakedb.Build(id=50, brid=41, number=5, start_time=1304262222),
fakedb.Build(id=51, brid=42, number=5, start_time=1304262222),
fakedb.Build(id=52, brid=42, number=6, start_time=1304262222),
])
d.addCallback(
lambda _: self.db.builds.finishBuilds([50, 51], _reactor=clock))
def check(_):
def thd(conn):
r = conn.execute(self.db.model.builds.select())
rows = [(row.id, row.brid, row.number, row.start_time,
row.finish_time) for row in r.fetchall()]
self.assertEqual(sorted(rows), [
(50, 41, 5, 1304262222, 1305555555),
(51, 42, 5, 1304262222, 1305555555),
(52, 42, 6, 1304262222, None),
])
return self.db.pool.do(thd)
d.addCallback(check)
return d
def test_finishBuilds_big(self):
clock = task.Clock()
clock.advance(1305555555)
d = self.insertTestData(self.background_data + [
fakedb.Build(id=nn, brid=41, number=nn, start_time=1304262222)
for nn in xrange(50, 200)
])
d.addCallback(lambda _: self.db.builds.finishBuilds(range(50, 200),
_reactor=clock))
def check(_):
def thd(conn):
r = conn.execute(self.db.model.builds.select())
rows = [(row.id, row.brid, row.number, row.start_time,
row.finish_time) for row in r.fetchall()]
self.assertEqual(sorted(rows),
[(nn, 41, nn, 1304262222, 1305555555)
for nn in xrange(50, 200)])
return self.db.pool.do(thd)
d.addCallback(check)
return d
@defer.inlineCallbacks
def test_getLastBuildsNumbersCodeBasesFound(self):
yield self.insertTestData(self.last_builds)
sourcestamps_filter = [{
'b_codebase': '1',
'b_branch': 'master'
}, {
'b_codebase': '2',
'b_branch': 'staging'
}]
lastBuildNumber = yield self.db.builds.getLastBuildsNumbers(
buildername="builder",
sourcestamps=sourcestamps_filter,
num_builds=1)
self.assertEqual(lastBuildNumber, [4])
@defer.inlineCallbacks
def test_getLastBuildsNumbersCodeBasesNotFound(self):
yield self.insertTestData(self.last_builds)
sourcestamps_filter = [{
'b_codebase': '1',
'b_branch': 'development'
}, {
'b_codebase': '2',
'b_branch': 'qa'
}]
lastBuildNumber = yield self.db.builds.getLastBuildsNumbers(
buildername="builder",
sourcestamps=sourcestamps_filter,
num_builds=1)
self.assertEqual(lastBuildNumber, [])
@defer.inlineCallbacks
def test_getLastBuildsNumbersOneFilter(self):
yield self.insertTestData(self.last_builds)
sourcestamps_filter = [{'b_codebase': '1', 'b_branch': 'master'}]
lastBuildNumber = yield self.db.builds.getLastBuildsNumbers(
buildername="builder",
sourcestamps=sourcestamps_filter,
num_builds=1)
self.assertEqual(lastBuildNumber, [4])
@defer.inlineCallbacks
def test_getLastBuildsNumbersMultipleBuilds(self):
builds = [
fakedb.BuildRequest(id=2,
buildsetid=2,
buildername="builder",
complete=1,
results=0,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.Buildset(id=2, sourcestampsetid=2),
fakedb.SourceStampSet(id=2),
fakedb.SourceStamp(id=3,
revision='a',
codebase='1',
sourcestampsetid=2,
branch='master',
repository='z'),
fakedb.SourceStamp(id=4,
revision='b',
codebase='4',
sourcestampsetid=2,
branch='development',
repository='w'),
fakedb.Build(id=2,
number=3,
brid=2,
start_time=self.SUBMITTED_AT_EPOCH,
finish_time=self.COMPLETE_AT_EPOCH)
]
yield self.insertTestData(self.last_builds + builds)
sourcestamps_filter = [{
'b_codebase': '1',
'b_branch': 'master'
}, {
'b_codebase': '2',
'b_branch': 'qa'
}]
lastBuildNumber = yield self.db.builds.getLastBuildsNumbers(
buildername="builder",
sourcestamps=sourcestamps_filter,
num_builds=4)
self.assertEqual(lastBuildNumber, [3])
@defer.inlineCallbacks
def test_getLastBuildsNumbersFilterBranchResults(self):
builds = [
fakedb.BuildRequest(id=2,
buildsetid=2,
buildername="builder",
complete=1,
results=4,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.Buildset(id=2, sourcestampsetid=2),
fakedb.SourceStampSet(id=2),
fakedb.SourceStamp(id=3,
revision='a',
codebase='1',
sourcestampsetid=2,
branch='master',
repository='z'),
fakedb.SourceStamp(id=4,
revision='b',
codebase='4',
sourcestampsetid=2,
branch='development',
repository='w'),
fakedb.Build(id=2,
number=3,
brid=2,
start_time=self.SUBMITTED_AT_EPOCH,
finish_time=self.COMPLETE_AT_EPOCH)
]
yield self.insertTestData(self.last_builds + builds)
sourcestamps_filter = [{'b_branch': 'master'}, {'b_branch': 'qa'}]
lastBuildNumber = yield self.db.builds.getLastBuildsNumbers(
buildername="builder",
sourcestamps=sourcestamps_filter,
results=[0],
num_builds=4)
self.assertEqual(lastBuildNumber, [4])
lastBuildNumber = yield self.db.builds.getLastBuildsNumbers(
buildername="builder",
sourcestamps=sourcestamps_filter,
results=[0, 4],
num_builds=4)
self.assertEqual(lastBuildNumber, [4, 3])
@defer.inlineCallbacks
def insertRecentBuilds(self):
builds = [{
'buildername': "builder",
'submitted_at': 1457706077,
'complete_at': 1457706089,
'revision': 'abzdewf',
'slavename': 'slave-02'
}, {
'buildername': "builder",
'submitted_at': 1457895804,
'complete_at': 1457895819,
'revision': 'zbzdewf',
'slavename': 'slave-01'
}, {
'buildername': "builder-01",
'submitted_at': 1457895804,
'complete_at': 1457895819,
'revision': 'zbzdewf',
'slavename': 'slave-01'
}, {
'buildername': "builder",
'submitted_at': self.SUBMITTED_AT_EPOCH,
'complete_at': self.COMPLETE_AT_EPOCH,
'revision': 'fwbzdeif',
'slavename': 'slave-01'
}]
recent_builds = []
for idx, b in enumerate(builds):
rowid = idx + 1
recent_builds += [
fakedb.BuildRequest(id=rowid,
buildsetid=rowid,
buildername=b['buildername'],
complete=1,
results=SUCCESS,
submitted_at=b['submitted_at'],
complete_at=b['complete_at']),
fakedb.Buildset(id=rowid, sourcestampsetid=rowid),
fakedb.SourceStampSet(id=rowid),
fakedb.SourceStamp(id=rowid,
revision=b['revision'],
codebase='1',
sourcestampsetid=rowid,
branch='master',
repository='z'),
fakedb.Build(id=rowid,
number=rowid,
brid=rowid,
start_time=b['submitted_at'],
finish_time=b['complete_at'],
slavename=b['slavename'])
]
yield self.insertTestData(recent_builds)
@defer.inlineCallbacks
def test_getLastBuildsNumbersOrderByCompleted(self):
yield self.insertRecentBuilds()
builds = yield self.db.builds.getLastBuildsNumbers(
buildername="builder")
self.assertEquals([2, 1, 4], builds)
@defer.inlineCallbacks
def test_getLastsBuildsNumbersBySlave(self):
builds = [
fakedb.BuildRequest(id=2,
buildsetid=2,
buildername="builder1",
complete=1,
results=0,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.Buildset(id=2, sourcestampsetid=2),
fakedb.SourceStampSet(id=2),
fakedb.SourceStamp(id=3,
revision='a',
codebase='1',
sourcestampsetid=2,
branch='master',
repository='z'),
fakedb.SourceStamp(id=4,
revision='b',
codebase='4',
sourcestampsetid=2,
branch='development',
repository='w'),
fakedb.Build(id=2,
number=3,
brid=2,
start_time=self.SUBMITTED_AT_EPOCH,
finish_time=self.COMPLETE_AT_EPOCH,
slavename='slave-01'),
fakedb.BuildRequest(id=3,
buildsetid=2,
buildername="builder2",
complete=1,
results=0,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.Build(id=3,
number=5,
brid=3,
start_time=self.SUBMITTED_AT_EPOCH,
finish_time=self.COMPLETE_AT_EPOCH,
slavename='slave-02')
]
yield self.insertTestData(self.last_builds + builds)
lastBuildNumber = yield self.db.builds.getLastsBuildsNumbersBySlave(
slavename='slave-01')
self.assertEqual(lastBuildNumber, {'builder': [4], 'builder1': [3]})
lastBuildNumber = yield self.db.builds.getLastsBuildsNumbersBySlave(
slavename='slave-02')
self.assertEqual(lastBuildNumber, {'builder2': [5]})
@defer.inlineCallbacks
def test_getLastsBuildsNumbersBySlaveFilterResults(self):
builds = [
fakedb.BuildRequest(id=2,
buildsetid=2,
buildername="builder1",
complete=1,
results=4,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.Buildset(id=2, sourcestampsetid=2),
fakedb.SourceStampSet(id=2),
fakedb.SourceStamp(id=3,
revision='a',
codebase='1',
sourcestampsetid=2,
branch='master',
repository='z'),
fakedb.SourceStamp(id=4,
revision='b',
codebase='4',
sourcestampsetid=2,
branch='development',
repository='w'),
fakedb.Build(id=2,
number=3,
brid=2,
start_time=self.SUBMITTED_AT_EPOCH,
finish_time=self.COMPLETE_AT_EPOCH,
slavename='slave-01'),
fakedb.BuildRequest(id=3,
buildsetid=2,
buildername="builder2",
complete=1,
results=7,
submitted_at=self.SUBMITTED_AT_EPOCH,
complete_at=self.COMPLETE_AT_EPOCH),
fakedb.Build(id=3,
number=5,
brid=3,
start_time=self.SUBMITTED_AT_EPOCH,
finish_time=self.COMPLETE_AT_EPOCH,
slavename='slave-02')
]
yield self.insertTestData(self.last_builds + builds)
lastBuildNumber = yield self.db.builds.getLastsBuildsNumbersBySlave(
slavename='slave-01', results=[0, 4])
self.assertEqual(lastBuildNumber, {'builder': [4], 'builder1': [3]})
lastBuildNumber = yield self.db.builds.getLastsBuildsNumbersBySlave(
slavename='slave-02', results=[7])
self.assertEqual(lastBuildNumber, {'builder2': [5]})
@defer.inlineCallbacks
def test_getLastsBuildsNumbersBySlaveOrderByCompleted(self):
yield self.insertRecentBuilds()
builds = yield self.db.builds.getLastsBuildsNumbersBySlave(
slavename="slave-01")
self.assertEquals(builds, {'builder-01': [3], 'builder': [2, 4]})
class Tests(interfaces.InterfaceTests):
# common sample data
backgroundData = [
fakedb.Buildset(id=20),
fakedb.Builder(id=77, name="b1"),
fakedb.Builder(id=88, name="b2"),
fakedb.BuildRequest(id=40, buildsetid=20, builderid=77),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=77),
fakedb.BuildRequest(id=42, buildsetid=20, builderid=88),
fakedb.Master(id=88),
fakedb.Master(id=89, name="bar"),
fakedb.Buildslave(id=13, name='sl'),
]
threeBuilds = [
fakedb.Build(id=50, buildrequestid=42, number=5, masterid=88,
builderid=77, buildslaveid=13, state_string="test",
started_at=TIME1),
fakedb.Build(id=51, buildrequestid=41, number=6, masterid=88,
builderid=88, buildslaveid=13, state_string="test",
started_at=TIME2),
fakedb.Build(id=52, buildrequestid=42, number=7, masterid=88,
builderid=77, buildslaveid=13, state_string="test",
started_at=TIME3, complete_at=TIME4, results=5),
]
threeBdicts = {
50: {'id': 50, 'buildrequestid': 42, 'builderid': 77,
'masterid': 88, 'number': 5, 'buildslaveid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': 'test',
'results': None},
51: {'id': 51, 'buildrequestid': 41, 'builderid': 88,
'masterid': 88, 'number': 6, 'buildslaveid': 13,
'started_at': epoch2datetime(TIME2),
'complete_at': None, 'state_string': 'test',
'results': None},
52: {'id': 52, 'buildrequestid': 42, 'builderid': 77,
'masterid': 88, 'number': 7, 'buildslaveid': 13,
'started_at': epoch2datetime(TIME3),
'complete_at': epoch2datetime(TIME4),
'state_string': 'test',
'results': 5},
}
# signature tests
def test_signature_getBuild(self):
@self.assertArgSpecMatches(self.db.builds.getBuild)
def getBuild(self, buildid):
pass
def test_signature_getBuildByNumber(self):
@self.assertArgSpecMatches(self.db.builds.getBuildByNumber)
def getBuild(self, builderid, number):
pass
def test_signature_getBuilds(self):
@self.assertArgSpecMatches(self.db.builds.getBuilds)
def getBuilds(self, builderid=None, buildrequestid=None):
pass
def test_signature_addBuild(self):
@self.assertArgSpecMatches(self.db.builds.addBuild)
def addBuild(self, builderid, buildrequestid, buildslaveid, masterid,
state_string):
pass
def test_signature_setBuildStateString(self):
@self.assertArgSpecMatches(self.db.builds.setBuildStateString)
def setBuildStateString(self, buildid, state_string):
pass
def test_signature_finishBuild(self):
@self.assertArgSpecMatches(self.db.builds.finishBuild)
def finishBuild(self, buildid, results):
pass
def test_signature_finishBuildsFromMaster(self):
@self.assertArgSpecMatches(self.db.builds.finishBuildsFromMaster)
def finishBuildsFromMaster(self, masterid, results):
pass
# method tests
@defer.inlineCallbacks
def test_getBuild(self):
yield self.insertTestData(self.backgroundData + [self.threeBuilds[0]])
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, buildslaveid=13,
started_at=epoch2datetime(TIME1), complete_at=None,
state_string=u'test', results=None))
@defer.inlineCallbacks
def test_getBuild_missing(self):
bdict = yield self.db.builds.getBuild(50)
self.assertEqual(bdict, None)
@defer.inlineCallbacks
def test_getBuildByNumber(self):
yield self.insertTestData(self.backgroundData + [self.threeBuilds[0]])
bdict = yield self.db.builds.getBuildByNumber(builderid=77, number=5)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict['id'], 50)
@defer.inlineCallbacks
def test_getBuilds(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds()
for bdict in bdicts:
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[50], self.threeBdicts[51],
self.threeBdicts[52]])
@defer.inlineCallbacks
def test_getBuilds_builderid(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(builderid=88)
for bdict in bdicts:
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[51]])
@defer.inlineCallbacks
def test_getBuilds_buildrequestid(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(buildrequestid=42)
for bdict in bdicts:
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[50], self.threeBdicts[52]])
@defer.inlineCallbacks
def test_addBuild_first(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData)
id, number = yield self.db.builds.addBuild(builderid=77,
buildrequestid=41, buildslaveid=13, masterid=88,
state_string=u'test test2', _reactor=clock)
bdict = yield self.db.builds.getBuild(id)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, {'buildrequestid': 41, 'builderid': 77,
'id': id, 'masterid': 88, 'number': number, 'buildslaveid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': u'test test2',
'results': None})
@defer.inlineCallbacks
def test_addBuild_existing(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData + [
fakedb.Build(number=10, buildrequestid=41, builderid=77,
masterid=88, buildslaveid=13),
])
id, number = yield self.db.builds.addBuild(builderid=77,
buildrequestid=41, buildslaveid=13, masterid=88,
state_string=u'test test2', _reactor=clock)
bdict = yield self.db.builds.getBuild(id)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(number, 11)
self.assertEqual(bdict, {'buildrequestid': 41, 'builderid': 77,
'id': id, 'masterid': 88, 'number': number, 'buildslaveid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': u'test test2',
'results': None})
@defer.inlineCallbacks
def test_setBuildStateString(self):
yield self.insertTestData(self.backgroundData + [self.threeBuilds[0]])
yield self.db.builds.setBuildStateString(buildid=50,
state_string=u'test test2')
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, buildslaveid=13,
started_at=epoch2datetime(TIME1), complete_at=None,
state_string=u'test test2', results=None))
@defer.inlineCallbacks
def test_finishBuild(self):
clock = task.Clock()
clock.advance(TIME4)
yield self.insertTestData(self.backgroundData + [self.threeBuilds[0]])
yield self.db.builds.finishBuild(buildid=50, results=7, _reactor=clock)
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, buildslaveid=13,
started_at=epoch2datetime(TIME1),
complete_at=epoch2datetime(TIME4),
state_string=u'test',
results=7))
@defer.inlineCallbacks
def test_finishBuildsFromMaster(self):
clock = task.Clock()
clock.advance(TIME4)
yield self.insertTestData(self.backgroundData + self.threeBuilds + [
fakedb.Build(
id=54, buildrequestid=40, number=50, masterid=89,
builderid=77, buildslaveid=13, state_string="test",
started_at=TIME1)
])
yield self.db.builds.finishBuildsFromMaster(masterid=88, results=7, _reactor=clock)
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, buildslaveid=13,
started_at=epoch2datetime(TIME1),
complete_at=epoch2datetime(TIME4),
state_string=u'test',
results=7))
for _id, results in [(50, 7), (51, 7), (52, 5), (54, None)]:
bdict = yield self.db.builds.getBuild(_id)
validation.verifyDbDict(self, 'builddict', bdict)
self.assertEqual(bdict['results'], results)
def run_fake_summary_build(self, gsp, buildResults, finalResult,
resultText):
buildpairs = []
i = 0
for i in xrange(len(buildResults)):
buildResult = buildResults[i]
builder = Mock()
build = FakeBuildStatus()
builder.getBuild.return_value = build
builder.name = "Builder-%d" % i
builder.getName.return_value = builder.name
build.results = buildResult
build.finished = True
build.reason = "testReason"
build.getBuilder.return_value = builder
build.getResults.return_value = build.results
build.getText.return_value = ['buildText']
build.getProperty = self.TEST_PROPS.get
buildpairs.append((builder, build))
def fakeGetBuilder(buildername):
# e.g. Builder-5 will be buildpairs[5][0]
return buildpairs[int(buildername.split("-")[1])][0]
gsp.master_status.getBuilder = fakeGetBuilder
gsp.master_status.getURLForThing = Mock()
gsp.master_status.getURLForThing.return_value = self.THING_URL
gsp.master.db = fakedb.FakeDBConnector(gsp.master, self)
fakedata = [
fakedb.Master(id=92),
fakedb.Buildslave(id=13, name='sl'),
fakedb.Buildset(id=99, results=finalResult, reason="testReason"),
]
breqid = 1000
for (builder, build) in buildpairs:
fakedata.append(
fakedb.BuildRequest(id=breqid,
buildsetid=99,
buildername=builder.name))
fakedata.append(
fakedb.Build(number=0,
buildrequestid=breqid,
masterid=92,
buildslaveid=13))
breqid = breqid + 1
gsp.master.db.insertTestData(fakedata)
d = gsp._buildsetComplete('buildset.99.complete',
dict(bsid=99, result=SUCCESS))
@d.addCallback
def check(_):
info = []
for i in xrange(len(buildResults)):
info.append({
'name': "Builder-%d" % i,
'result': buildResults[i],
'resultText': resultText[i],
'text': 'buildText',
'url': self.THING_URL
})
return str(info)
return d
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 performd 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
d = master.db.buildrequests.getBuildRequest(288)
d.addCallback(lambda brdict: brDicts.append(brdict))
d.addCallback(lambda _: master.db.buildrequests.getBuildRequest(289))
d.addCallback(lambda brdict: brDicts.append(brdict))
d.addCallback(lambda _: buildrequest.BuildRequest.canBeCollapsed(
master, brDicts[0], brDicts[1]))
def check(canBeCollapsed):
self.assertEqual(canBeCollapsed, False)
d.addCallback(check)
return d
