def do_test_sendToInterestedUsers(self, lookup=None, extraRecipients=[],
sendToInterestedUsers=True,
exp_called_with=None, exp_TO=None,
exp_CC=None):
from email.Message import Message
m = Message()
mn = MailNotifier(fromaddr='*****@*****.**',
lookup=lookup,
sendToInterestedUsers=sendToInterestedUsers,
extraRecipients=extraRecipients)
mn.sendMessage = Mock()
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername":"Builder", "brid":1}])
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = FakeBuildStatus(name="build")
build.result = FAILURE
build.finished = True
build.reason = "testReason"
build.builder = builder
def fakeCreateEmail(msgdict, builderName, title, results, builds=None,
patches=None, logs=None):
# only concerned with m['To'] and m['CC'], which are added in
# _got_recipients later
return defer.succeed(m)
mn.createEmail = fakeCreateEmail
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([fakedb.SourceStampSet(id=1099),
fakedb.Buildset(id=99, sourcestampsetid=1099,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99,
buildername='Builder'),
fakedb.Build(number=0, brid=11),
fakedb.Change(changeid=9123),
fakedb.ChangeUser(changeid=9123, uid=1),
fakedb.User(uid=1, identifier="tdurden"),
fakedb.UserInfo(uid=1, attr_type='svn',
attr_data="tdurden"),
fakedb.UserInfo(uid=1, attr_type='email',
attr_data="*****@*****.**")
])
# fake sourcestamp with relevant user bits
ss = Mock(name="sourcestamp")
fake_change = Mock(name="change")
fake_change.number = 9123
ss.changes = [fake_change]
ss.patch, ss.addPatch = None, None
def fakeGetSSlist():
return [ss]
build.getSourceStamps = fakeGetSSlist
def _getInterestedUsers():
# 'narrator' in this case is the owner, which tests the lookup
return ["Big Bob <*****@*****.**>", "narrator"]
build.getInterestedUsers = _getInterestedUsers
def _getResponsibleUsers():
return ["Big Bob <*****@*****.**>"]
build.getResponsibleUsers = _getResponsibleUsers
mn.master = self # FIXME: Should be FakeMaster
self.status = mn.master_status = mn.buildMessageDict = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict.return_value = {"body": "body", "type": "text"}
mn.buildMessage(builder.name, [build], build.result)
mn.sendMessage.assert_called_with(m, exp_called_with)
self.assertEqual(m['To'], exp_TO)
self.assertEqual(m['CC'], exp_CC)
def test_sendToInterestedUsers_two_builds(self):
from email.Message import Message
m = Message()
mn = MailNotifier(fromaddr="*****@*****.**", lookup=None)
mn.sendMessage = Mock()
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername":"Builder", "brid":1}])
builder = Mock()
builder.name = "Builder"
build1 = FakeBuildStatus(name="build")
build1.result = FAILURE
build1.finished = True
build1.reason = "testReason"
build1.builder = builder
build2 = FakeBuildStatus(name="build")
build2.result = FAILURE
build2.finished = True
build2.reason = "testReason"
build2.builder = builder
def fakeCreateEmail(msgdict, builderName, title, results, builds=None,
patches=None, logs=None):
# only concerned with m['To'] and m['CC'], which are added in
# _got_recipients later
return defer.succeed(m)
mn.createEmail = fakeCreateEmail
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([fakedb.SourceStampSet(id=1099),
fakedb.Buildset(id=99, sourcestampsetid=1099,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99,
buildername='Builder'),
fakedb.Build(number=0, brid=11),
fakedb.Build(number=1, brid=11),
fakedb.Change(changeid=9123),
fakedb.Change(changeid=9124),
fakedb.ChangeUser(changeid=9123, uid=1),
fakedb.ChangeUser(changeid=9124, uid=2),
fakedb.User(uid=1, identifier="tdurden"),
fakedb.User(uid=2, identifier="user2"),
fakedb.UserInfo(uid=1, attr_type='email',
attr_data="*****@*****.**"),
fakedb.UserInfo(uid=2, attr_type='email',
attr_data="*****@*****.**")
])
def _getInterestedUsers():
# 'narrator' in this case is the owner, which tests the lookup
return ["Big Bob <*****@*****.**>", "narrator"]
build1.getInterestedUsers = _getInterestedUsers
build2.getInterestedUsers = _getInterestedUsers
def _getResponsibleUsers():
return ["Big Bob <*****@*****.**>"]
build1.getResponsibleUsers = _getResponsibleUsers
build2.getResponsibleUsers = _getResponsibleUsers
# fake sourcestamp with relevant user bits
ss1 = Mock(name="sourcestamp")
fake_change1 = Mock(name="change")
fake_change1.number = 9123
ss1.changes = [fake_change1]
ss1.patch, ss1.addPatch = None, None
ss2 = Mock(name="sourcestamp")
fake_change2 = Mock(name="change")
fake_change2.number = 9124
ss2.changes = [fake_change2]
ss2.patch, ss1.addPatch = None, None
def fakeGetSSlist(ss):
return lambda: [ss]
build1.getSourceStamps = fakeGetSSlist(ss1)
build2.getSourceStamps = fakeGetSSlist(ss2)
mn.master = self # FIXME: Should be FakeMaster
self.status = mn.master_status = mn.buildMessageDict = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict.return_value = {"body": "body", "type": "text"}
mn.buildMessage(builder.name, [build1, build2], build1.result)
self.assertEqual(m['To'], "[email protected], [email protected]")
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(self)
fakedata = [
fakedb.SourceStampSet(id=127),
fakedb.Buildset(id=99,
sourcestampsetid=127,
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, brid=breqid))
breqid = breqid + 1
gsp.master.db.insertTestData(fakedata)
d = gsp._buildsetComplete(99, finalResult)
@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',
'build': buildpairs[i][1],
'url': self.THING_URL
})
return str(info)
return d
def test_getCustomMesgData_single_sourcestamp(self):
self.passedAttrs = {}
def fakeCustomMessage(attrs):
self.passedAttrs = attrs
return ("", "")
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode=("failing", "passing", "warnings"),
builders=["Builder"])
def fakeBuildMessage(name, builds, results):
for build in builds:
mn.buildMessageDict(name=build.getBuilder().name,
build=build, results=build.results)
mn.buildMessage = fakeBuildMessage
mn.customMesg = fakeCustomMessage
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername":"Builder", "brid":1}])
self.db = fakedb.FakeDBConnector(self)
self.db.insertTestData([fakedb.SourceStampSet(id=127),
fakedb.Buildset(id=99, sourcestampsetid=127,
results=SUCCESS,
reason="testReason"),
fakedb.BuildRequest(id=11, buildsetid=99,
buildername='Builder'),
fakedb.Build(number=0, brid=11),
])
mn.master = self
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = FakeBuildStatus()
build.results = FAILURE
build.finished = True
build.reason = "testReason"
build.getLogs.return_value = []
build.getBuilder.return_value = builder
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
ss1 = FakeSource(revision='111222', codebase='testlib1')
build.getSourceStamps.return_value = [ss1]
mn.buildsetFinished(99, FAILURE)
self.assertTrue('builderName' in self.passedAttrs, "No builderName entry found in attrs")
self.assertEqual(self.passedAttrs['builderName'], 'Builder')
self.assertTrue('revision' in self.passedAttrs, "No revision entry found in attrs")
self.assertTrue(isinstance(self.passedAttrs['revision'], str))
self.assertEqual(self.passedAttrs['revision'], '111222')
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77),
fakedb.Worker(id=13, name='wrk'),
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 setupStep(self,
step,
sourcestampsInBuild=None,
force_rebuild=False,
force_chain_rebuild=False,
configuredMergeFnResponse=True,
*args,
**kwargs):
sourcestamps = sourcestampsInBuild or []
got_revisions = {}
steps.BuildStepMixin.setupStep(self, step, *args, **kwargs)
m = fakemaster.make_master()
self.build.builder.botmaster = m.botmaster
m.db = fakedb.FakeDBConnector(self)
m.status = master.Status(m)
m.config.buildbotURL = "baseurl/"
m.db.mastersconfig.setupMaster()
if len(sourcestamps) < 1:
ss = FakeSourceStamp(codebase='c',
repository='https://url/project',
branch='mybranch',
revision=3,
sourcestampsetid=3)
sourcestamps.append(ss)
def getAllSourceStamps():
return sourcestamps
self.build.getAllSourceStamps = getAllSourceStamps
self.build.build_status.getSourceStamps = getAllSourceStamps
if force_rebuild:
self.build.setProperty("force_rebuild", True,
"FindPreviousBuildTest")
if force_chain_rebuild:
self.build.setProperty("force_chain_rebuild", True,
"FindPreviousBuildTest")
def getAllGotRevisions():
return got_revisions
self.build.build_status.getAllGotRevisions = getAllGotRevisions
def getSourceValues():
return [mock.Mock()]
buildRequest = mock.Mock()
buildRequest.id = 1
buildRequest.sources.values = getSourceValues
self.build.requests = [buildRequest]
self.build.builder.config.name = "A"
self.build.builder.config.builddir = "build"
def getConfiguredMergeRequestsFn():
return configuredMergeFnResponse
self.build.builder.getConfiguredMergeRequestsFn = getConfiguredMergeRequestsFn
self.build.builder.builder_status.getFriendlyName = lambda: "A"
def addURL(name, url, results=None):
self.step_status.urls[name] = url
if results is not None:
self.step_status.urls[name] = {'url': url, 'results': results}
self.step_status.addURL = addURL
fake_buildset = fakedb.Buildset(id=1, sourcestampsetid=1)
fake_br = fakedb.BuildRequest(id=1,
buildsetid=1,
buildername="A",
complete=1,
results=0)
fake_ss = fakedb.SourceStamp(id=1,
branch='master',
repository='https://url/project',
codebase='c',
revision='12',
sourcestampsetid=1)
fake_build = fakedb.Build(id=1, number=1, brid=1)
m.db.insertTestData([fake_buildset, fake_br, fake_ss, fake_build])
m.db.buildrequests.setRelatedSourcestamps(1, [
FakeSourceStamp(codebase='c',
repository='https://url/project',
branch='master',
revision=12,
sourcestampsetid=1)
])
def setupBuild(self):
self.master.db.insertTestData([
fakedb.Build(id=1, masterid=1, workerid=1,
builderid=self.BUILDER_IDS[0],
buildrequestid=1, number=1),
])
class Tests(interfaces.InterfaceTests):
TIMESTAMP_STEP101 = 100000
TIMESTAMP_STEP102 = 200000
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',
started_at=TIMESTAMP_STEP101),
fakedb.Step(id=102,
buildid=30,
number=2,
name='two',
started_at=TIMESTAMP_STEP102),
]
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
def test_signature_deleteOldLogChunks(self):
@self.assertArgSpecMatches(self.db.logs.deleteOldLogChunks)
def deleteOldLogChunks(self, older_than_timestamp):
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_getCustomMesgData_multiple_sourcestamps(self):
self.passedAttrs = {}
def fakeCustomMessage(attrs):
self.passedAttrs = attrs
return ("", "")
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode=("failing", "passing", "warnings"),
builders=["Builder"])
def fakeBuildMessage(name, builds, results):
for build in builds:
mn.buildMessageDict(name=build.getBuilder().name,
build=build,
results=build.results)
mn.buildMessage = fakeBuildMessage
mn.customMesg = fakeCustomMessage
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername": "Builder", "brid": 1}])
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Buildslave(id=13, name='sl'),
fakedb.Buildset(id=99, results=SUCCESS, reason="testReason"),
fakedb.Builder(id=80, name='Builder'),
fakedb.BuildRequest(id=11, buildsetid=99, builderid=80),
fakedb.Build(number=0,
buildrequestid=11,
buildslaveid=13,
masterid=92),
])
mn.master = self.master
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = FakeBuildStatus()
build.results = FAILURE
build.finished = True
build.reason = "testReason"
build.getLogs.return_value = []
build.getBuilder.return_value = builder
build.getResults.return_value = build.results
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
ss1 = FakeSource(revision='111222', codebase='testlib1')
ss2 = FakeSource(revision='222333', codebase='testlib2')
build.getSourceStamps.return_value = [ss1, ss2]
d = mn._buildsetComplete('buildset.99.complete',
dict(bsid=99, result=FAILURE))
@d.addCallback
def check(_):
self.assertTrue('revision' in self.passedAttrs,
"No revision entry found in attrs")
self.assertTrue(isinstance(self.passedAttrs['revision'], dict))
self.assertEqual(self.passedAttrs['revision']['testlib1'],
'111222')
self.assertEqual(self.passedAttrs['revision']['testlib2'],
'222333')
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=u'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 test_buildsetComplete_doesnt_send_email(self):
fakeBuildMessage = Mock()
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode=("failing", "warnings"),
builders=["Builder"])
mn.buildMessage = fakeBuildMessage
def fakeGetBuild(number):
return build
def fakeGetBuilder(buildername):
if buildername == builder.name:
return builder
return None
def fakeGetBuildRequests(self, bsid):
return defer.succeed([{"buildername": "Builder", "brid": 1}])
builder = Mock()
builder.getBuild = fakeGetBuild
builder.name = "Builder"
build = FakeBuildStatus()
build.results = SUCCESS
build.finished = True
build.reason = "testReason"
build.getBuilder.return_value = builder
build.getResults.return_value = build.results
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Buildslave(id=13, name='sl'),
fakedb.Buildset(id=99, results=SUCCESS, reason="testReason"),
fakedb.Builder(id=80, name='Builder'),
fakedb.BuildRequest(id=11, buildsetid=99, builderid=80),
fakedb.Build(number=0,
buildrequestid=11,
buildslaveid=13,
masterid=92),
])
mn.master = self.master
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict = Mock()
mn.buildMessageDict.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
d = mn._buildsetComplete('buildset.99.complete',
dict(bsid=99, result=FAILURE))
@d.addCallback
def check(_):
self.assertFalse(fakeBuildMessage.called)
return d
def test_buildsetComplete_sends_email(self):
fakeBuildMessage = Mock()
mn = MailNotifier('*****@*****.**',
buildSetSummary=True,
mode=("failing", "passing", "warnings"),
builders=["Builder1", "Builder2"])
mn.buildMessage = fakeBuildMessage
builder1 = Mock()
builder1.getBuild = lambda number: build1
builder1.name = "Builder1"
build1 = FakeBuildStatus()
build1.results = FAILURE
build1.finished = True
build1.reason = "testReason"
build1.getBuilder.return_value = builder1
build1.getResults.return_value = build1.results
builder2 = Mock()
builder2.getBuild = lambda number: build2
builder2.name = "Builder2"
build2 = FakeBuildStatus()
build2.results = FAILURE
build2.finished = True
build2.reason = "testReason"
build2.getBuilder.return_value = builder1
build2.getResults.return_value = build2.results
def fakeGetBuilder(buildername):
return {"Builder1": builder1, "Builder2": builder2}[buildername]
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Buildslave(id=13, name='sl'),
fakedb.Buildset(id=99, results=SUCCESS, reason="testReason"),
fakedb.Builder(id=80, name='Builder1'),
fakedb.Builder(id=81, name='Builder2'),
fakedb.BuildRequest(id=11, buildsetid=99, builderid=80),
fakedb.Build(number=0,
buildrequestid=11,
buildslaveid=13,
masterid=92),
fakedb.BuildRequest(id=12, buildsetid=99, builderid=81),
fakedb.Build(number=0,
buildrequestid=12,
buildslaveid=13,
masterid=92),
])
mn.master = self.master
self.status = Mock()
mn.master_status = Mock()
mn.master_status.getBuilder = fakeGetBuilder
mn.buildMessageDict = Mock()
mn.buildMessageDict.return_value = {
"body": "body",
"type": "text",
"subject": "subject"
}
d = mn._buildsetComplete('buildset.99.complete',
dict(bsid=99, result=FAILURE))
@d.addCallback
def check(_):
fakeBuildMessage.assert_called_with("(whole buildset)",
[build1, build2], SUCCESS)
return d
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.Worker(id=13, name='wrk'),
fakedb.Worker(id=12, name='sl2'),
]
threeBuilds = [
fakedb.Build(id=50, buildrequestid=42, number=5, masterid=88,
builderid=77, workerid=13, state_string="build 5",
started_at=TIME1),
fakedb.Build(id=51, buildrequestid=41, number=6, masterid=88,
builderid=88, workerid=13, state_string="build 6",
started_at=TIME2),
fakedb.Build(id=52, buildrequestid=42, number=7, masterid=88,
builderid=77, workerid=12, state_string="build 7",
started_at=TIME3, complete_at=TIME4, results=5),
]
threeBdicts = {
50: {'id': 50, 'buildrequestid': 42, 'builderid': 77,
'masterid': 88, 'number': 5, 'workerid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': 'build 5',
'results': None},
51: {'id': 51, 'buildrequestid': 41, 'builderid': 88,
'masterid': 88, 'number': 6, 'workerid': 13,
'started_at': epoch2datetime(TIME2),
'complete_at': None, 'state_string': 'build 6',
'results': None},
52: {'id': 52, 'buildrequestid': 42, 'builderid': 77,
'masterid': 88, 'number': 7, 'workerid': 12,
'started_at': epoch2datetime(TIME3),
'complete_at': epoch2datetime(TIME4),
'state_string': 'build 7',
'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, workerid=None,
complete=None, resultSpec=None):
pass
def test_signature_addBuild(self):
@self.assertArgSpecMatches(self.db.builds.addBuild)
def addBuild(self, builderid, buildrequestid, workerid, 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_getBuildProperties(self):
@self.assertArgSpecMatches(self.db.builds.getBuildProperties)
def getBuildProperties(self, bid):
pass
def test_signature_setBuildProperty(self):
@self.assertArgSpecMatches(self.db.builds.setBuildProperty)
def setBuildProperty(self, bid, name, value, source):
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, 'dbbuilddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, workerid=13,
started_at=epoch2datetime(TIME1), complete_at=None,
state_string='build 5', 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, 'dbbuilddict', 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, 'dbbuilddict', 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, 'dbbuilddict', 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, 'dbbuilddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[50], self.threeBdicts[52]])
@defer.inlineCallbacks
def test_getBuilds_workerid(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(workerid=13)
for bdict in bdicts:
validation.verifyDbDict(self, 'dbbuilddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[self.threeBdicts[50], self.threeBdicts[51]])
@defer.inlineCallbacks
def test_getBuilds_complete(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
bdicts = yield self.db.builds.getBuilds(complete=True)
for bdict in bdicts:
validation.verifyDbDict(self, 'dbbuilddict', bdict)
self.assertEqual(sorted(bdicts, key=lambda bd: bd['id']),
[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, workerid=13, masterid=88,
state_string='test test2', _reactor=clock)
bdict = yield self.db.builds.getBuild(id)
validation.verifyDbDict(self, 'dbbuilddict', bdict)
self.assertEqual(bdict, {'buildrequestid': 41, 'builderid': 77,
'id': id, 'masterid': 88, 'number': number, 'workerid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': '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, workerid=13),
])
id, number = yield self.db.builds.addBuild(builderid=77,
buildrequestid=41, workerid=13, masterid=88,
state_string='test test2', _reactor=clock)
bdict = yield self.db.builds.getBuild(id)
validation.verifyDbDict(self, 'dbbuilddict', bdict)
self.assertEqual(number, 11)
self.assertEqual(bdict, {'buildrequestid': 41, 'builderid': 77,
'id': id, 'masterid': 88, 'number': number, 'workerid': 13,
'started_at': epoch2datetime(TIME1),
'complete_at': None, 'state_string': '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='test test2')
bdict = yield self.db.builds.getBuild(50)
validation.verifyDbDict(self, 'dbbuilddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, workerid=13,
started_at=epoch2datetime(TIME1), complete_at=None,
state_string='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, 'dbbuilddict', bdict)
self.assertEqual(bdict, dict(id=50, number=5, buildrequestid=42,
masterid=88, builderid=77, workerid=13,
started_at=epoch2datetime(TIME1),
complete_at=epoch2datetime(TIME4),
state_string='build 5',
results=7))
@defer.inlineCallbacks
def testgetBuildPropertiesEmpty(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
for buildid in (50, 51, 52):
props = yield self.db.builds.getBuildProperties(buildid)
self.assertEqual(0, len(props))
@defer.inlineCallbacks
def testsetandgetProperties(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
yield self.db.builds.setBuildProperty(50, 'prop', 42, 'test')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (42, 'test')})
@defer.inlineCallbacks
def testsetgetsetProperties(self):
yield self.insertTestData(self.backgroundData + self.threeBuilds)
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {})
yield self.db.builds.setBuildProperty(50, 'prop', 42, 'test')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (42, 'test')})
# set a new value
yield self.db.builds.setBuildProperty(50, 'prop', 45, 'test')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (45, 'test')})
# set a new source
yield self.db.builds.setBuildProperty(50, 'prop', 45, 'test_source')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (45, 'test_source')})
# set the same
yield self.db.builds.setBuildProperty(50, 'prop', 45, 'test_source')
props = yield self.db.builds.getBuildProperties(50)
self.assertEqual(props, {'prop': (45, 'test_source')})
class Tests(interfaces.InterfaceTests):
# common sample data
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.Build(id=31, buildrequestid=41, number=8, masterid=88,
builderid=88, workerid=47),
]
stepRows = [
fakedb.Step(id=70, number=0, name='one', buildid=30,
started_at=TIME1, complete_at=TIME2,
state_string=u'test', results=0),
fakedb.Step(id=71, number=1, name='two', buildid=30,
started_at=TIME2, complete_at=TIME3,
state_string=u'test', results=2,
urls_json=u'["http://url"]',
hidden=1),
fakedb.Step(id=72, number=2, name='three', buildid=30,
started_at=TIME3),
fakedb.Step(id=73, number=0, name='wrong-build', buildid=31),
]
stepDicts = [
{'id': 70, 'buildid': 30, 'number': 0, 'name': u'one',
'results': 0,
'started_at': epoch2datetime(TIME1),
'complete_at': epoch2datetime(TIME2),
'state_string': u'test',
'urls': [],
'hidden': False},
{'id': 71, 'buildid': 30, 'number': 1, 'name': u'two',
'results': 2,
'started_at': epoch2datetime(TIME2),
'complete_at': epoch2datetime(TIME3),
'state_string': u'test',
'urls': [u'http://url'],
'hidden': True},
{'id': 72, 'buildid': 30, 'number': 2, 'name': u'three',
'results': None,
'started_at': epoch2datetime(TIME3),
'complete_at': None,
'state_string': u'',
'urls': [],
'hidden': False},
]
# signature tests
def test_signature_getStep(self):
@self.assertArgSpecMatches(self.db.steps.getStep)
def getStep(self, stepid=None, buildid=None, number=None, name=None):
pass
def test_signature_getSteps(self):
@self.assertArgSpecMatches(self.db.steps.getSteps)
def getSteps(self, buildid):
pass
def test_signature_addStep(self):
@self.assertArgSpecMatches(self.db.steps.addStep)
def addStep(self, buildid, name, state_string):
pass
def test_signature_startStep(self):
@self.assertArgSpecMatches(self.db.steps.startStep)
def addStep(self, stepid):
pass
def test_signature_setStepStateString(self):
@self.assertArgSpecMatches(self.db.steps.setStepStateString)
def setStepStateString(self, stepid, state_string):
pass
def test_signature_finishStep(self):
@self.assertArgSpecMatches(self.db.steps.finishStep)
def finishStep(self, stepid, results, hidden):
pass
# method tests
@defer.inlineCallbacks
def test_getStep(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[0]])
stepdict = yield self.db.steps.getStep(70)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict, self.stepDicts[0])
@defer.inlineCallbacks
def test_getStep_missing(self):
stepdict = yield self.db.steps.getStep(50)
self.assertEqual(stepdict, None)
@defer.inlineCallbacks
def test_getStep_number(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[1]])
stepdict = yield self.db.steps.getStep(buildid=30, number=1)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['id'], 71)
@defer.inlineCallbacks
def test_getStep_number_missing(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[1]])
stepdict = yield self.db.steps.getStep(buildid=30, number=9)
self.assertEqual(stepdict, None)
@defer.inlineCallbacks
def test_getStep_name(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
stepdict = yield self.db.steps.getStep(buildid=30,
name='three')
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['id'], 72)
@defer.inlineCallbacks
def test_getStep_name_missing(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
stepdict = yield self.db.steps.getStep(buildid=30, name='five')
self.assertEqual(stepdict, None)
def test_getStep_invalid(self):
d = self.db.steps.getStep(buildid=30)
self.assertFailure(d, RuntimeError)
@defer.inlineCallbacks
def test_getSteps(self):
yield self.insertTestData(self.backgroundData + self.stepRows)
stepdicts = yield self.db.steps.getSteps(buildid=30)
[validation.verifyDbDict(self, 'stepdict', stepdict)
for stepdict in stepdicts]
self.assertEqual(stepdicts, self.stepDicts[:3])
@defer.inlineCallbacks
def test_getSteps_none(self):
yield self.insertTestData(self.backgroundData + self.stepRows)
stepdicts = yield self.db.steps.getSteps(buildid=33)
self.assertEqual(stepdicts, [])
@defer.inlineCallbacks
def test_addStep_getStep(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData)
stepid, number, name = yield self.db.steps.addStep(buildid=30,
name=u'new', state_string=u'new')
yield self.db.steps.startStep(stepid=stepid, _reactor=clock)
self.assertEqual((number, name), (0, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict, {
'id': stepid,
'buildid': 30,
'name': u'new',
'number': 0,
'started_at': epoch2datetime(TIME1),
'complete_at': None,
'results': None,
'state_string': u'new',
'urls': [],
'hidden': False})
@defer.inlineCallbacks
def test_addStep_getStep_existing_step(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData + [self.stepRows[0]])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name=u'new', state_string=u'new')
yield self.db.steps.startStep(stepid=stepid, _reactor=clock)
self.assertEqual((number, name), (1, 'new'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['number'], number)
self.assertEqual(stepdict['name'], name)
@defer.inlineCallbacks
def test_addStep_getStep_name_collisions(self):
clock = task.Clock()
clock.advance(TIME1)
yield self.insertTestData(self.backgroundData + [
fakedb.Step(id=73, number=0, name=u'new', buildid=30),
fakedb.Step(id=74, number=1, name=u'new_1', buildid=30),
fakedb.Step(id=75, number=2, name=u'new_2', buildid=30),
fakedb.Step(id=76, number=3, name=u'new_step', buildid=30),
])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name=u'new', state_string=u'new')
yield self.db.steps.startStep(stepid=stepid, _reactor=clock)
self.assertEqual((number, name), (4, u'new_3'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['number'], number)
self.assertEqual(stepdict['name'], name)
@defer.inlineCallbacks
def test_setStepStateString(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield self.db.steps.setStepStateString(stepid=72,
state_string=u'aaa')
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['state_string'], u'aaa')
@defer.inlineCallbacks
def test_addURL(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield self.db.steps.addURL(stepid=72, name=u'foo', url=u'bar')
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['urls'], [{'name': u'foo', 'url': u'bar'}])
@defer.inlineCallbacks
def test_addURL_race(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield defer.gatherResults([
# only a tiny sleep is required to see the problem.
self.db.steps.addURL(stepid=72, name=u'foo', url=u'bar',
_racehook=lambda: time.sleep(.01)),
self.db.steps.addURL(stepid=72, name=u'foo2', url=u'bar2')])
stepdict = yield self.db.steps.getStep(stepid=72)
# order is not garanteed though
self.assertEqual(sorted(stepdict['urls']), [{'name': u'foo', 'url': u'bar'},
{'name': u'foo2', 'url': u'bar2'}])
@defer.inlineCallbacks
def test_finishStep(self):
clock = task.Clock()
clock.advance(TIME2)
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield self.db.steps.finishStep(stepid=72, results=11, hidden=False,
_reactor=clock)
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['results'], 11)
self.assertEqual(stepdict['complete_at'], epoch2datetime(TIME2))
self.assertEqual(stepdict['hidden'], False)
@defer.inlineCallbacks
def test_finishStep_hidden(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield self.db.steps.finishStep(stepid=72, results=11, hidden=True)
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['hidden'], True)
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=u'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 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)
def setUp(self):
authzcfg = authz.Authz(
stringsMatcher=authz.
fnmatchStrMatcher, # simple matcher with '*' glob character
# stringsMatcher = authz.Authz.reStrMatcher, # if you prefer regular expressions
allowRules=[
# admins can do anything,
# defaultDeny=False: if user does not have the admin role, we continue parsing rules
AnyEndpointMatcher(role="admins", defaultDeny=False),
# rules for viewing builds, builders, step logs
# depending on the sourcestamp or buildername
ViewBuildsEndpointMatcher(branch="secretbranch",
role="agents"),
ViewBuildsEndpointMatcher(project="secretproject",
role="agents"),
ViewBuildsEndpointMatcher(branch="*", role="*"),
ViewBuildsEndpointMatcher(project="*", role="*"),
StopBuildEndpointMatcher(role="owner"),
# nine-* groups can do stuff on the nine branch
BranchEndpointMatcher(branch="nine", role="nine-*"),
# eight-* groups can do stuff on the eight branch
BranchEndpointMatcher(branch="eight", role="eight-*"),
# *-try groups can start "try" builds
ForceBuildEndpointMatcher(builder="try", role="*-developers"),
# *-mergers groups can start "merge" builds
ForceBuildEndpointMatcher(builder="merge", role="*-mergers"),
# *-releasers groups can start "release" builds
ForceBuildEndpointMatcher(builder="release",
role="*-releasers"),
],
roleMatchers=[
RolesFromGroups(groupPrefix="buildbot-"),
RolesFromEmails(admins=["*****@*****.**"],
agents=["*****@*****.**"]),
RolesFromOwner(role="owner")
])
self.users = dict(homer=dict(email="*****@*****.**"),
bond=dict(email="*****@*****.**"),
nineuser=dict(email="*****@*****.**",
groups=[
"buildbot-nine-mergers",
"buildbot-nine-developers"
]),
eightuser=dict(email="*****@*****.**",
groups=["buildbot-eight-deverlopers"
]))
self.master = self.make_master(url='h:/a/b/', authz=authzcfg)
self.authz = self.master.authz
self.master.db.insertTestData([
fakedb.Builder(id=77, name="mybuilder"),
fakedb.Master(id=88),
fakedb.Buildslave(id=13, name='sl'),
fakedb.Buildset(id=8822),
fakedb.BuildsetProperty(
buildsetid=8822,
property_name='owner',
property_value='["*****@*****.**", "force"]'),
fakedb.BuildRequest(id=82, buildsetid=8822, builderid=77),
fakedb.Build(id=13,
builderid=77,
masterid=88,
buildslaveid=13,
buildrequestid=82,
number=3),
fakedb.Build(id=14,
builderid=77,
masterid=88,
buildslaveid=13,
buildrequestid=82,
number=4),
fakedb.Build(id=15,
builderid=77,
masterid=88,
buildslaveid=13,
buildrequestid=82,
number=5),
])
def insertTestData(self, buildResults, finalResult, insertSS=True):
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrk'),
fakedb.Builder(id=79, name='Builder0'),
fakedb.Builder(id=80, name='Builder1'),
fakedb.Buildset(id=98, results=finalResult, reason="testReason1"),
fakedb.Change(changeid=13,
branch='master',
revision='9283',
author='me@foo',
repository=self.TEST_REPO,
codebase=self.TEST_CODEBASE,
project='world-domination',
sourcestampid=234),
])
if insertSS:
self.db.insertTestData([
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(id=234,
project=self.TEST_PROJECT,
revision=self.TEST_REVISION,
repository=self.TEST_REPO,
codebase=self.TEST_CODEBASE)
])
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="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='Unicode log with non-ascii (\u00E5\u00E4\u00F6).'
),
fakedb.BuildProperty(buildid=20 + i,
name="workername",
value="wrk"),
fakedb.BuildProperty(buildid=20 + i,
name="reason",
value="because"),
fakedb.BuildProperty(buildid=20 + i,
name="buildername",
value="Builder0"),
])
for k, v in self.TEST_PROPS.items():
self.db.insertTestData(
[fakedb.BuildProperty(buildid=20 + i, name=k, value=v)])
def setupStep(self,
step,
sourcestampsInBuild=None,
gotRevisionsInBuild=None,
*args,
**kwargs):
sourcestamps = sourcestampsInBuild or []
got_revisions = gotRevisionsInBuild or {}
steps.BuildStepMixin.setupStep(self, step, *args, **kwargs)
# This step reaches deeply into a number of parts of Buildbot. That
# should be fixed!
# set up a buildmaster that knows about two fake schedulers, a and b
m = self.master
m.db.checkForeignKeys = True
self.build.builder.botmaster = m.botmaster
m.status = master.Status()
m.status.setServiceParent(m)
m.config.buildbotURL = "baseurl/"
m.scheduler_manager = FakeSchedulerManager()
self.scheduler_a = a = FakeTriggerable(name='a')
self.scheduler_b = b = FakeTriggerable(name='b')
m.scheduler_manager.namedServices = dict(a=a, b=b)
a.brids = {77: 11}
b.brids = {78: 22}
make_fake_br = lambda brid, builderid: fakedb.BuildRequest(
id=brid, buildsetid=BRID_TO_BSID(brid), builderid=builderid)
make_fake_build = lambda brid: fakedb.Build(buildrequestid=brid,
id=BRID_TO_BID(brid),
number=
BRID_TO_BUILD_NUMBER(brid),
masterid=9,
buildslaveid=13)
m.db.insertTestData([
fakedb.Builder(id=77, name='A'),
fakedb.Builder(id=78, name='B'),
fakedb.Master(id=9),
fakedb.Buildset(id=2022),
fakedb.Buildset(id=2011),
fakedb.Buildslave(id=13, name="some:slave"),
make_fake_br(11, 77),
make_fake_br(22, 78),
make_fake_build(11),
make_fake_build(22),
])
def getAllSourceStamps():
return sourcestamps
self.build.getAllSourceStamps = getAllSourceStamps
def getAllGotRevisions():
return got_revisions
self.step.getAllGotRevisions = getAllGotRevisions
self.exp_add_sourcestamp = None
self.exp_a_trigger = None
self.exp_b_trigger = None
self.exp_added_urls = []
