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_addStep_getStep_name_collisions_too_long(self):
self.reactor.advance(TIME1)
yield self.insertTestData(self.backgroundData + [
fakedb.Step(id=73, number=0, name='a' * 49, buildid=30),
fakedb.Step(id=74, number=1, name='a' * 48 + '_1', buildid=30),
])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='a' * 49, state_string='new')
yield self.db.steps.startStep(stepid=stepid)
self.assertEqual((number, name), (2, 'a' * 48 + '_2'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['number'], number)
self.assertEqual(stepdict['name'], name)
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
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=131, number=132, name='step132', buildid=30),
fakedb.TestResultSet(id=13,
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
complete=1),
fakedb.TestResultSet(id=14,
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
complete=1),
])
def test_addStep_getStep_name_collisions_too_long_extra_digits(self):
self.reactor.advance(TIME1)
yield self.insertTestData(self.backgroundData + [
fakedb.Step(id=73, number=0, name='a' * 50, buildid=30),
] + [fakedb.Step(id=73 + i, number=i, name='a' * 48 + ('_%d' % i), buildid=30)
for i in range(1, 10)
] + [fakedb.Step(id=73 + i, number=i, name='a' * 47 + ('_%d' % i), buildid=30)
for i in range(10, 100)
])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='a' * 50, state_string='new')
yield self.db.steps.startStep(stepid=stepid)
self.assertEqual((number, name), (100, 'a' * 46 + '_100'))
stepdict = yield self.db.steps.getStep(stepid=stepid)
validation.verifyDbDict(self, 'stepdict', stepdict)
self.assertEqual(stepdict['number'], number)
self.assertEqual(stepdict['name'], name)
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Worker(id=47, name='linux'),
fakedb.Builder(id=77, name='builder77'),
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 test_masterDeactivated(self):
self.master.db.insertTestData([
fakedb.Master(id=14, name='other', active=0,
last_active=0),
# set up a running build with some steps
fakedb.Builder(id=77, name='b1'),
fakedb.Worker(id=13, name='wrk'),
fakedb.Buildset(id=8822),
fakedb.BuildRequest(id=82, builderid=77, buildsetid=8822),
fakedb.BuildRequestClaim(brid=82, masterid=14,
claimed_at=SOMETIME),
fakedb.Build(id=13, builderid=77, masterid=14, workerid=13,
buildrequestid=82, number=3, results=None),
fakedb.Step(id=200, buildid=13),
fakedb.Log(id=2000, stepid=200, num_lines=2),
fakedb.LogChunk(logid=2000, first_line=1, last_line=2,
content='ab\ncd')
])
# mock out the _masterDeactivated methods this will call
for rtype in 'builder', 'scheduler', 'changesource':
rtype_obj = getattr(self.master.data.rtypes, rtype)
m = mock.Mock(name=f'{rtype}._masterDeactivated',
spec=rtype_obj._masterDeactivated)
m.side_effect = lambda masterid: defer.succeed(None)
rtype_obj._masterDeactivated = m
# and the update methods..
for meth in 'finishBuild', 'finishStep', 'finishLog':
m = mock.create_autospec(getattr(self.master.data.updates, meth))
m.side_effect = lambda *args, **kwargs: defer.succeed(None)
setattr(self.master.data.updates, meth, m)
yield self.rtype._masterDeactivated(14, 'other')
self.master.data.rtypes.builder._masterDeactivated. \
assert_called_with(masterid=14)
self.master.data.rtypes.scheduler._masterDeactivated. \
assert_called_with(masterid=14)
self.master.data.rtypes.changesource._masterDeactivated. \
assert_called_with(masterid=14)
# see that we finished off that build and its steps and logs
updates = self.master.data.updates
updates.finishLog.assert_called_with(logid=2000)
updates.finishStep.assert_called_with(
stepid=200, results=RETRY, hidden=False)
updates.finishBuild.assert_called_with(buildid=13, results=RETRY)
self.assertEqual(self.master.mq.productions, [
(('masters', '14', 'stopped'),
dict(masterid=14, name='other', active=False)),
])
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='trunk', revision='9283', author='me@foo',
repository='svn://...', codebase='cbsvn',
project='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='Unicode log with non-ascii (\u00E5\u00E4\u00F6).'),
fakedb.Patch(id=99, patch_base64='aGVsbG8sIHdvcmxk',
patch_author='him@foo', patch_comment='foo', subdir='/foo',
patchlevel=3),
])
for _id in (20,):
self.db.insertTestData([
fakedb.BuildProperty(
buildid=_id, name="workername", value="wrk"),
fakedb.BuildProperty(
buildid=_id, name="reason", value="because"),
fakedb.BuildProperty(
buildid=_id, name="scheduler", value="checkin"),
fakedb.BuildProperty(
buildid=_id, name="branch", value="master"),
])
res = yield utils.getDetailsForBuildset(self.master, 98, wantProperties=True,
wantPreviousBuild=wantPreviousBuild)
builds = res['builds']
buildset = res['buildset']
@defer.inlineCallbacks
def getChangesForBuild(buildid):
assert buildid == 20
ch = yield self.master.db.changes.getChange(13)
return [ch]
self.master.db.changes.getChangesForBuild = getChangesForBuild
return (buildset, builds)
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
fakedb.Builder(id=77),
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=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.setup_test_reactor()
self.master = fakemaster.make_master(self, wantData=True, wantDb=True)
yield self.master.startService()
self.master.db.insertTestData([
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=131, number=132, name='step132', buildid=30),
])
def setUp(self):
self.setUpEndpoint()
self.db.insertTestData([
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=131, number=132, name='step132', buildid=30),
fakedb.TestResultSet(id=13,
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
complete=1),
fakedb.TestName(id=301, builderid=88, name='name301'),
fakedb.TestName(id=302, builderid=88, name='name302'),
fakedb.TestCodePath(id=401, builderid=88, path='path401'),
fakedb.TestCodePath(id=402, builderid=88, path='path402'),
fakedb.TestResult(id=101,
builderid=88,
test_result_setid=13,
line=400,
value='v101'),
fakedb.TestResult(id=102,
builderid=88,
test_result_setid=13,
test_nameid=301,
test_code_pathid=401,
line=401,
value='v102'),
fakedb.TestResult(id=103,
builderid=88,
test_result_setid=13,
test_nameid=302,
test_code_pathid=402,
line=402,
duration_ns=1012,
value='v103'),
])
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.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=f"{i:08d}")
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 insertTestData(self,
buildResults,
finalResult,
insertSS=True,
parentPlan=False,
insert_patch=False):
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",
parent_buildid=19 if parentPlan else None),
fakedb.Change(changeid=13,
branch=self.TEST_BRANCH,
revision='9283',
author='me@foo',
repository=self.TEST_REPO,
codebase=self.TEST_CODEBASE,
project='world-domination',
sourcestampid=234),
])
if parentPlan:
self.db.insertTestData([
fakedb.Worker(id=12, name='wrk_parent'),
fakedb.Builder(id=78, name='Builder_parent'),
fakedb.Buildset(id=97,
results=finalResult,
reason="testReason0"),
fakedb.BuildRequest(id=10, buildsetid=98, builderid=78),
fakedb.Build(id=19,
number=1,
builderid=78,
buildrequestid=10,
workerid=12,
masterid=92,
results=finalResult,
state_string="buildText"),
])
if insertSS:
patchid = 99 if insert_patch else None
self.db.insertTestData([
fakedb.BuildsetSourceStamp(buildsetid=98, sourcestampid=234),
fakedb.SourceStamp(id=234,
branch=self.TEST_BRANCH,
project=self.TEST_PROJECT,
revision=self.TEST_REVISION,
repository=self.TEST_REPO,
codebase=self.TEST_CODEBASE,
patchid=patchid),
fakedb.Patch(id=99,
patch_base64='aGVsbG8sIHdvcmxk',
patch_author='him@foo',
patch_comment='foo',
subdir='/foo',
patchlevel=3),
])
for i, results in enumerate(buildResults):
started_at = 10000001
complete_at = None if results is None else 10000005
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",
started_at=started_at,
complete_at=complete_at),
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"),
fakedb.BuildProperty(buildid=20 + i,
name="buildnumber",
value="{}".format(i)),
fakedb.BuildProperty(buildid=20 + i,
name="scheduler",
value="checkin"),
])
for k, v in self.TEST_PROPS.items():
self.db.insertTestData(
[fakedb.BuildProperty(buildid=20 + i, name=k, value=v)])
@defer.inlineCallbacks
def getChangesForBuild(buildid):
assert buildid == 20
ch = yield self.master.db.changes.getChange(13)
return [ch]
self.master.db.changes.getChangesForBuild = getChangesForBuild
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='stdio',
slug='stdio',
complete=0,
num_lines=7,
type='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='problems',
slug='problems',
complete=1,
num_lines=11,
type='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='stdio',
slug='stdio',
complete=0,
num_lines=200,
type='s'),
])
logdict = yield self.db.logs.getLog(201)
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(
logdict, {
'id': 201,
'stepid': 101,
'name': 'stdio',
'slug': '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='stdio',
slug='stdio',
complete=0,
num_lines=200,
type='s'),
fakedb.Log(id=202,
stepid=101,
name='dbg.log',
slug='dbg_log',
complete=1,
num_lines=200,
type='s'),
])
logdict = yield self.db.logs.getLogBySlug(101, '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='stdio',
slug='stdio',
complete=0,
num_lines=200,
type='s'),
])
logdict = yield self.db.logs.getLogBySlug(102, 'stdio')
self.assertEqual(logdict, None)
@defer.inlineCallbacks
def test_getLogs(self):
yield self.insertTestData(self.backgroundData + [
fakedb.Log(id=201,
stepid=101,
name='stdio',
slug='stdio',
complete=0,
num_lines=200,
type='s'),
fakedb.Log(id=202,
stepid=101,
name='dbg.log',
slug='dbg_log',
complete=1,
num_lines=300,
type='t'),
fakedb.Log(id=203,
stepid=102,
name='stdio',
slug='stdio',
complete=0,
num_lines=200,
type='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='stdio',
slug='stdio',
complete=0,
num_lines=200,
type='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 = bytes2unicode(self.bug3101Content + b'\n')
self.assertEqual((yield self.db.logs.getLogLines(1470, 0, 99)),
expected)
# try to fetch just one line
expected = bytes2unicode(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='config.log',
slug='config_log',
type='t')
logdict = yield self.db.logs.getLog(logid)
validation.verifyDbDict(self, 'logdict', logdict)
self.assertEqual(
logdict, {
'id': logid,
'stepid': 101,
'name': 'config.log',
'slug': '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='another',
slug='another',
type='s')
self.assertEqual((yield self.db.logs.appendLog(logid, 'xyz\n')),
(0, 0))
self.assertEqual((yield self.db.logs.appendLog(201, 'abc\ndef\n')),
(7, 8))
self.assertEqual((yield self.db.logs.appendLog(logid, 'XYZ\n')),
(1, 1))
self.assertEqual((yield self.db.logs.getLogLines(201, 6, 7)),
"yet another line\nabc\n")
self.assertEqual((yield self.db.logs.getLogLines(201, 7, 8)),
"abc\ndef\n")
self.assertEqual((yield self.db.logs.getLogLines(201, 8, 8)), "def\n")
self.assertEqual((yield self.db.logs.getLogLines(logid, 0, 1)),
"xyz\nXYZ\n")
self.assertEqual(
(yield self.db.logs.getLog(logid)), {
'complete': False,
'id': logid,
'name': 'another',
'slug': 'another',
'num_lines': 2,
'stepid': 102,
'type': '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, 'abc\n' * 20000)), # 80k
(7, 20006))
lines = yield self.db.logs.getLogLines(201, 7, 50000)
self.assertEqual(len(lines), 80000)
self.assertEqual(lines, ('abc\n' * 20000))
@defer.inlineCallbacks
def test_addLogLines_big_chunk_big_lines(self):
yield self.insertTestData(self.backgroundData + self.testLogLines)
line = '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))
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='test', results=0),
fakedb.Step(id=71, number=1, name='two', buildid=30,
started_at=TIME2, complete_at=TIME3,
state_string='test', results=2,
urls_json='["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': 'one',
'results': 0,
'started_at': epoch2datetime(TIME1),
'complete_at': epoch2datetime(TIME2),
'state_string': 'test',
'urls': [],
'hidden': False},
{'id': 71, 'buildid': 30, 'number': 1, 'name': 'two',
'results': 2,
'started_at': epoch2datetime(TIME2),
'complete_at': epoch2datetime(TIME3),
'state_string': 'test',
'urls': ['http://url'],
'hidden': True},
{'id': 72, 'buildid': 30, 'number': 2, 'name': 'three',
'results': None,
'started_at': epoch2datetime(TIME3),
'complete_at': None,
'state_string': '',
'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)
@defer.inlineCallbacks
def test_getStep_invalid(self):
d = self.db.steps.getStep(buildid=30)
yield 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):
self.reactor.advance(TIME1)
yield self.insertTestData(self.backgroundData)
stepid, number, name = yield self.db.steps.addStep(buildid=30,
name='new',
state_string='new')
yield self.db.steps.startStep(stepid=stepid)
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': 'new',
'number': 0,
'started_at': epoch2datetime(TIME1),
'complete_at': None,
'results': None,
'state_string': 'new',
'urls': [],
'hidden': False})
@defer.inlineCallbacks
def test_addStep_getStep_existing_step(self):
self.reactor.advance(TIME1)
yield self.insertTestData(self.backgroundData + [self.stepRows[0]])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new')
yield self.db.steps.startStep(stepid=stepid)
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):
self.reactor.advance(TIME1)
yield self.insertTestData(self.backgroundData + [
fakedb.Step(id=73, number=0, name='new', buildid=30),
fakedb.Step(id=74, number=1, name='new_1', buildid=30),
fakedb.Step(id=75, number=2, name='new_2', buildid=30),
fakedb.Step(id=76, number=3, name='new_step', buildid=30),
])
stepid, number, name = yield self.db.steps.addStep(
buildid=30, name='new', state_string='new')
yield self.db.steps.startStep(stepid=stepid)
self.assertEqual((number, name), (4, '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='aaa')
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['state_string'], 'aaa')
@defer.inlineCallbacks
def test_addURL(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield self.db.steps.addURL(stepid=72, name='foo', url='bar')
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['urls'], [{'name': 'foo', 'url': '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='foo', url='bar',
_racehook=lambda: time.sleep(.01)),
self.db.steps.addURL(stepid=72, name='foo2', url='bar2')])
stepdict = yield self.db.steps.getStep(stepid=72)
def urlKey(url):
return url['name']
# order is not guaranteed though
self.assertEqual(sorted(stepdict['urls'], key=urlKey),
sorted([{'name': 'foo', 'url': 'bar'},
{'name': 'foo2', 'url': 'bar2'}],
key=urlKey))
@defer.inlineCallbacks
def test_addURL_no_duplicate(self):
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield defer.gatherResults([
self.db.steps.addURL(stepid=72, name='foo', url='bar'),
self.db.steps.addURL(stepid=72, name='foo', url='bar')])
stepdict = yield self.db.steps.getStep(stepid=72)
self.assertEqual(stepdict['urls'],
[{'name': 'foo', 'url': 'bar'}])
@defer.inlineCallbacks
def test_finishStep(self):
self.reactor.advance(TIME2)
yield self.insertTestData(self.backgroundData + [self.stepRows[2]])
yield self.db.steps.finishStep(stepid=72, results=11, hidden=False)
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 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)])
class Tests(interfaces.InterfaceTests):
common_data = [
fakedb.Worker(id=47, name='linux'),
fakedb.Buildset(id=20),
fakedb.Builder(id=88, name='b1'),
fakedb.Builder(id=89, name='b2'),
fakedb.BuildRequest(id=41, buildsetid=20, builderid=88),
fakedb.BuildRequest(id=42, buildsetid=20, builderid=88),
fakedb.BuildRequest(id=43, 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=42,
number=8,
masterid=88,
builderid=88,
workerid=47),
fakedb.Build(id=40,
buildrequestid=43,
number=9,
masterid=88,
builderid=89,
workerid=47),
fakedb.Step(id=131, number=231, name='step231', buildid=30),
fakedb.Step(id=132, number=232, name='step232', buildid=30),
fakedb.Step(id=141, number=241, name='step241', buildid=31),
fakedb.Step(id=142, number=242, name='step242', buildid=40),
]
common_test_result_set_data = [
fakedb.TestResultSet(id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=0),
fakedb.TestResultSet(id=92,
builderid=88,
buildid=30,
stepid=131,
description='desc2',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1),
]
def test_signature_add_test_result_set(self):
@self.assertArgSpecMatches(self.db.test_result_sets.addTestResultSet)
def addTestResultSet(self, builderid, buildid, stepid, description,
category, value_unit):
pass
def test_signature_get_test_result_set(self):
@self.assertArgSpecMatches(self.db.test_result_sets.getTestResultSet)
def getTestResultSet(self, test_result_setid):
pass
def test_signature_get_test_result_sets(self):
@self.assertArgSpecMatches(self.db.test_result_sets.getTestResultSets)
def getTestResultSets(self,
builderid,
buildid=None,
stepid=None,
complete=None,
result_spec=None):
pass
def test_signature_complete_test_result_set(self):
@self.assertArgSpecMatches(
self.db.test_result_sets.completeTestResultSet)
def completeTestResultSet(self,
test_result_setid,
tests_passed=None,
tests_failed=None):
pass
@defer.inlineCallbacks
def test_add_set_get_set(self):
yield self.insertTestData(self.common_data)
set_id = yield self.db.test_result_sets.addTestResultSet(
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms')
set_dict = yield self.db.test_result_sets.getTestResultSet(set_id)
validation.verifyDbDict(self, 'test_result_setdict', set_dict)
self.assertEqual(
set_dict, {
'id': set_id,
'builderid': 88,
'buildid': 30,
'stepid': 131,
'description': 'desc',
'category': 'cat',
'value_unit': 'ms',
'tests_failed': None,
'tests_passed': None,
'complete': False
})
@defer.inlineCallbacks
def test_get_sets(self):
yield self.insertTestData(self.common_data + [
fakedb.TestResultSet(id=91,
builderid=88,
buildid=30,
stepid=131,
description='desc1',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=0),
fakedb.TestResultSet(id=92,
builderid=89,
buildid=40,
stepid=142,
description='desc2',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1),
fakedb.TestResultSet(id=93,
builderid=88,
buildid=31,
stepid=141,
description='desc3',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1),
fakedb.TestResultSet(id=94,
builderid=88,
buildid=30,
stepid=132,
description='desc4',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=1),
fakedb.TestResultSet(id=95,
builderid=88,
buildid=30,
stepid=131,
description='desc4',
category='cat',
value_unit='ms',
tests_failed=None,
tests_passed=None,
complete=0),
])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88)
self.assertEqual([d['id'] for d in set_dicts], [91, 93, 94, 95])
for d in set_dicts:
validation.verifyDbDict(self, 'test_result_setdict', d)
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=89)
self.assertEqual([d['id'] for d in set_dicts], [92])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88, buildid=30)
self.assertEqual([d['id'] for d in set_dicts], [91, 94, 95])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88, buildid=31)
self.assertEqual([d['id'] for d in set_dicts], [93])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88, stepid=131)
self.assertEqual([d['id'] for d in set_dicts], [91, 95])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88, stepid=132)
self.assertEqual([d['id'] for d in set_dicts], [94])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88, complete=True)
self.assertEqual([d['id'] for d in set_dicts], [93, 94])
set_dicts = yield self.db.test_result_sets.getTestResultSets(
builderid=88, complete=False)
self.assertEqual([d['id'] for d in set_dicts], [91, 95])
@defer.inlineCallbacks
def test_get_set_from_data(self):
yield self.insertTestData(self.common_data +
self.common_test_result_set_data)
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(
set_dict, {
'id': 91,
'builderid': 88,
'buildid': 30,
'stepid': 131,
'description': 'desc1',
'category': 'cat',
'value_unit': 'ms',
'tests_failed': None,
'tests_passed': None,
'complete': False
})
@defer.inlineCallbacks
def test_get_non_existing_set(self):
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(set_dict, None)
@defer.inlineCallbacks
def test_complete_already_completed_set(self):
yield self.insertTestData(self.common_data +
self.common_test_result_set_data)
with self.assertRaises(test_result_sets.TestResultSetAlreadyCompleted):
yield self.db.test_result_sets.completeTestResultSet(92)
self.flushLoggedErrors(test_result_sets.TestResultSetAlreadyCompleted)
@defer.inlineCallbacks
def test_complete_set_with_test_counts(self):
yield self.insertTestData(self.common_data +
self.common_test_result_set_data)
yield self.db.test_result_sets.completeTestResultSet(91,
tests_passed=12,
tests_failed=2)
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(
set_dict, {
'id': 91,
'builderid': 88,
'buildid': 30,
'stepid': 131,
'description': 'desc1',
'category': 'cat',
'value_unit': 'ms',
'tests_failed': 2,
'tests_passed': 12,
'complete': True
})
@defer.inlineCallbacks
def test_complete_set_without_test_counts(self):
yield self.insertTestData(self.common_data +
self.common_test_result_set_data)
yield self.db.test_result_sets.completeTestResultSet(91)
set_dict = yield self.db.test_result_sets.getTestResultSet(91)
self.assertEqual(
set_dict, {
'id': 91,
'builderid': 88,
'buildid': 30,
'stepid': 131,
'description': 'desc1',
'category': 'cat',
'value_unit': 'ms',
'tests_failed': None,
'tests_passed': None,
'complete': True
})
def insert_initial_data(self):
self.master.db.insertTestData([
fakedb.Master(id=1),
fakedb.Worker(id=1, name='example-worker'),
fakedb.Scheduler(id=1, name='custom', enabled=1),
fakedb.Scheduler(id=2, name='all', enabled=2),
fakedb.Scheduler(id=3, name='force', enabled=3),
fakedb.SchedulerMaster(schedulerid=1, masterid=1),
fakedb.SchedulerMaster(schedulerid=2, masterid=1),
fakedb.SchedulerMaster(schedulerid=3, masterid=1),
fakedb.Builder(id=1, name='runtests1'),
fakedb.Builder(id=2, name='runtests2'),
fakedb.Builder(id=3, name='runtests3'),
fakedb.BuilderMaster(id=1, builderid=1, masterid=1),
fakedb.BuilderMaster(id=2, builderid=2, masterid=1),
fakedb.BuilderMaster(id=3, builderid=3, masterid=1),
fakedb.Tag(id=1, name='tag1'),
fakedb.Tag(id=2, name='tag12'),
fakedb.Tag(id=3, name='tag23'),
fakedb.BuildersTags(id=1, builderid=1, tagid=1),
fakedb.BuildersTags(id=2, builderid=1, tagid=2),
fakedb.BuildersTags(id=3, builderid=2, tagid=2),
fakedb.BuildersTags(id=4, builderid=2, tagid=3),
fakedb.BuildersTags(id=5, builderid=3, tagid=3),
fakedb.Buildset(id=1,
results=SUCCESS,
reason="Force reason 1",
submitted_at=100000,
complete_at=100110,
complete=1),
fakedb.Buildset(id=2,
results=SUCCESS,
reason="Force reason 2",
submitted_at=100200,
complete_at=100330,
complete=1),
fakedb.Buildset(id=3,
results=SUCCESS,
reason="Force reason 3",
submitted_at=100400,
complete_at=100550,
complete=1),
fakedb.BuildsetProperty(buildsetid=1,
property_name='scheduler',
property_value='["custom", "Scheduler"]'),
fakedb.BuildsetProperty(buildsetid=2,
property_name='scheduler',
property_value='["all", "Scheduler"]'),
fakedb.BuildsetProperty(buildsetid=3,
property_name='scheduler',
property_value='["force", "Scheduler"]'),
fakedb.BuildsetProperty(
buildsetid=3,
property_name='owner',
property_value='["*****@*****.**", "Force Build Form"]'),
fakedb.SourceStamp(id=1, branch='master', revision='1234abcd'),
fakedb.Change(changeid=1,
branch='master',
revision='1234abcd',
sourcestampid=1),
fakedb.ChangeProperty(
changeid=1,
property_name="owner",
property_value='["*****@*****.**", "change"]'),
fakedb.ChangeProperty(changeid=1,
property_name="other_prop",
property_value='["value", "change"]'),
fakedb.BuildsetSourceStamp(id=1, buildsetid=1, sourcestampid=1),
fakedb.BuildsetSourceStamp(id=2, buildsetid=2, sourcestampid=1),
fakedb.BuildsetSourceStamp(id=3, buildsetid=3, sourcestampid=1),
fakedb.BuildRequest(id=1,
buildsetid=1,
builderid=1,
results=SUCCESS,
submitted_at=100001,
complete_at=100109,
complete=1),
fakedb.BuildRequest(id=2,
buildsetid=2,
builderid=1,
results=SUCCESS,
submitted_at=100201,
complete_at=100329,
complete=1),
fakedb.BuildRequest(id=3,
buildsetid=3,
builderid=2,
results=SUCCESS,
submitted_at=100401,
complete_at=100549,
complete=1),
fakedb.Build(id=1,
number=1,
buildrequestid=1,
builderid=1,
workerid=1,
masterid=1001,
started_at=100002,
complete_at=100108,
state_string='build successful',
results=SUCCESS),
fakedb.Build(id=2,
number=2,
buildrequestid=2,
builderid=1,
workerid=1,
masterid=1001,
started_at=100202,
complete_at=100328,
state_string='build successful',
results=SUCCESS),
fakedb.Build(id=3,
number=1,
buildrequestid=3,
builderid=2,
workerid=1,
masterid=1001,
started_at=100402,
complete_at=100548,
state_string='build successful',
results=SUCCESS),
fakedb.BuildProperty(buildid=3,
name='reason',
value='"force build"',
source="Force Build Form"),
fakedb.BuildProperty(buildid=3,
name='owner',
value='"*****@*****.**"',
source="Force Build Form"),
fakedb.BuildProperty(buildid=3,
name='scheduler',
value='"force"',
source="Scheduler"),
fakedb.BuildProperty(buildid=3,
name='buildername',
value='"runtests3"',
source="Builder"),
fakedb.BuildProperty(buildid=3,
name='workername',
value='"example-worker"',
source="Worker"),
fakedb.Step(id=1,
number=1,
name='step1',
buildid=1,
started_at=100010,
complete_at=100019,
state_string='step1 done'),
fakedb.Step(id=2,
number=2,
name='step2',
buildid=1,
started_at=100020,
complete_at=100029,
state_string='step2 done'),
fakedb.Step(id=3,
number=3,
name='step3',
buildid=1,
started_at=100030,
complete_at=100039,
state_string='step3 done'),
fakedb.Step(id=11,
number=1,
name='step1',
buildid=2,
started_at=100210,
complete_at=100219,
state_string='step1 done'),
fakedb.Step(id=12,
number=2,
name='step2',
buildid=2,
started_at=100220,
complete_at=100229,
state_string='step2 done'),
fakedb.Step(id=13,
number=3,
name='step3',
buildid=2,
started_at=100230,
complete_at=100239,
state_string='step3 done'),
fakedb.Step(id=21,
number=1,
name='step1',
buildid=3,
started_at=100410,
complete_at=100419,
state_string='step1 done'),
fakedb.Step(id=22,
number=2,
name='step2',
buildid=3,
started_at=100420,
complete_at=100429,
state_string='step2 done'),
fakedb.Step(id=23,
number=3,
name='step3',
buildid=3,
started_at=100430,
complete_at=100439,
state_string='step3 done'),
fakedb.Log(id=1,
name='stdio',
slug='stdio',
stepid=1,
complete=1,
num_lines=10),
fakedb.Log(id=2,
name='stdio',
slug='stdio',
stepid=2,
complete=1,
num_lines=20),
fakedb.Log(id=3,
name='stdio',
slug='stdio',
stepid=3,
complete=1,
num_lines=30),
fakedb.Log(id=11,
name='stdio',
slug='stdio',
stepid=11,
complete=1,
num_lines=30),
fakedb.Log(id=12,
name='stdio',
slug='stdio',
stepid=12,
complete=1,
num_lines=40),
fakedb.Log(id=13,
name='stdio',
slug='stdio',
stepid=13,
complete=1,
num_lines=50),
fakedb.Log(id=21,
name='stdio',
slug='stdio',
stepid=21,
complete=1,
num_lines=50),
fakedb.Log(id=22,
name='stdio',
slug='stdio',
stepid=22,
complete=1,
num_lines=60),
fakedb.Log(id=23,
name='stdio',
slug='stdio',
stepid=23,
complete=1,
num_lines=70),
fakedb.LogChunk(logid=1,
first_line=0,
last_line=2,
content='o line1\no line2\n'),
fakedb.LogChunk(logid=1,
first_line=2,
last_line=3,
content='o line3\n'),
fakedb.LogChunk(logid=2,
first_line=0,
last_line=4,
content='o line1\no line2\no line3\no line4\n'),
])
def setup_db(self,
results1,
results2,
with_steps=False,
extra_build_properties=None):
if extra_build_properties is None:
extra_build_properties = {}
self.db = self.master.db
self.db.insertTestData([
fakedb.Master(id=92),
fakedb.Worker(id=13, name='wrkr'),
fakedb.Buildset(id=98, results=results1, reason="testReason1"),
fakedb.Buildset(id=99, results=results2, reason="testReason2"),
fakedb.Builder(id=80, name='Builder1'),
fakedb.BuildRequest(id=11, buildsetid=98, builderid=80),
fakedb.BuildRequest(id=12, buildsetid=99, builderid=80),
fakedb.Build(id=20,
number=0,
builderid=80,
buildrequestid=11,
workerid=13,
masterid=92,
results=results1),
fakedb.Build(id=21,
number=1,
builderid=80,
buildrequestid=12,
workerid=13,
masterid=92,
results=results2),
])
for build_id in (20, 21):
self.db.insertTestData([
fakedb.BuildProperty(buildid=build_id,
name="workername",
value="wrkr"),
fakedb.BuildProperty(buildid=build_id,
name="reason",
value="because"),
])
for name, value in extra_build_properties.items():
self.db.insertTestData([
fakedb.BuildProperty(buildid=build_id,
name=name,
value=value),
])
if with_steps:
self.db.insertTestData([
fakedb.Step(id=151,
buildid=21,
number=1,
results=SUCCESS,
name='first step'),
fakedb.Step(id=152,
buildid=21,
number=2,
results=results2,
name='second step'),
fakedb.Step(id=153,
buildid=21,
number=3,
results=SUCCESS,
name='third step'),
fakedb.Log(id=251,
stepid=152,
name='stdio',
slug='stdio',
type='s',
num_lines=7),
fakedb.Log(id=252,
stepid=152,
name='stderr',
slug='stderr',
type='s',
num_lines=7),
fakedb.Log(id=253,
stepid=153,
name='stdio',
slug='stdio',
type='s',
num_lines=7),
])
class Tests(interfaces.InterfaceTests):
common_data = [
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=131, number=132, name='step132', buildid=30),
fakedb.TestResultSet(id=13,
builderid=88,
buildid=30,
stepid=131,
description='desc',
category='cat',
value_unit='ms',
complete=1),
]
def test_signature_get_test_code_paths(self):
@self.assertArgSpecMatches(self.db.test_results.getTestCodePaths)
def getTestCodePaths(self,
builderid,
path_prefix=None,
result_spec=None):
pass
def test_signature_get_test_names(self):
@self.assertArgSpecMatches(self.db.test_results.getTestNames)
def getTestNames(self, builderid, name_prefix=None, result_spec=None):
pass
def test_signature_add_test_results(self):
@self.assertArgSpecMatches(self.db.test_results.addTestResults)
def addTestResults(self, builderid, test_result_setid, result_values):
pass
def test_signature_get_test_result(self):
@self.assertArgSpecMatches(self.db.test_results.getTestResult)
def getTestResult(self, test_resultid):
pass
def test_signature_get_test_results(self):
@self.assertArgSpecMatches(self.db.test_results.getTestResults)
def getTestResults(self,
builderid,
test_result_setid,
result_spec=None):
pass
@defer.inlineCallbacks
def test_add_set_results(self):
yield self.insertTestData(self.common_data)
result_values = [
{
'test_name': 'name1',
'value': '1'
},
{
'test_name': 'name1',
'duration_ns': 1000,
'value': '2'
},
{
'test_name': 'name2',
'test_code_path': 'path2',
'value': '3'
},
{
'test_name': 'name3',
'test_code_path': 'path3',
'value': '4'
},
{
'test_name': 'name4',
'test_code_path': 'path4',
'line': 4,
'value': '5'
},
{
'test_code_path': 'path5',
'line': 5,
'value': '6'
},
]
yield self.db.test_results.addTestResults(builderid=88,
test_result_setid=13,
result_values=result_values)
result_dicts = yield self.db.test_results.getTestResults(
builderid=88, test_result_setid=13)
for d in result_dicts:
validation.verifyDbDict(self, 'test_resultdict', d)
result_dicts = sorted(result_dicts, key=lambda x: x['id'])
resultid = result_dicts[0]['id']
self.assertEqual(result_dicts, [
{
'id': resultid,
'builderid': 88,
'test_result_setid': 13,
'test_name': 'name1',
'test_code_path': None,
'line': None,
'duration_ns': None,
'value': '1'
},
{
'id': resultid + 1,
'builderid': 88,
'test_result_setid': 13,
'test_name': 'name1',
'test_code_path': None,
'line': None,
'duration_ns': 1000,
'value': '2'
},
{
'id': resultid + 2,
'builderid': 88,
'test_result_setid': 13,
'test_name': 'name2',
'test_code_path': 'path2',
'line': None,
'duration_ns': None,
'value': '3'
},
{
'id': resultid + 3,
'builderid': 88,
'test_result_setid': 13,
'test_name': 'name3',
'test_code_path': 'path3',
'line': None,
'duration_ns': None,
'value': '4'
},
{
'id': resultid + 4,
'builderid': 88,
'test_result_setid': 13,
'test_name': 'name4',
'test_code_path': 'path4',
'line': 4,
'duration_ns': None,
'value': '5'
},
{
'id': resultid + 5,
'builderid': 88,
'test_result_setid': 13,
'test_name': None,
'test_code_path': 'path5',
'line': 5,
'duration_ns': None,
'value': '6'
},
])
result_dict = yield self.db.test_results.getTestResult(
test_resultid=resultid)
self.assertEqual(
result_dict, {
'id': resultid,
'builderid': 88,
'test_result_setid': 13,
'test_name': 'name1',
'test_code_path': None,
'line': None,
'duration_ns': None,
'value': '1'
})
@defer.inlineCallbacks
def test_get_names(self):
yield self.insertTestData(self.common_data + [
fakedb.TestName(id=103, builderid=88, name='name103'),
fakedb.TestName(id=104, builderid=88, name='name104'),
fakedb.TestName(id=105, builderid=88, name='name105'),
fakedb.TestName(id=116, builderid=88, name='name116'),
fakedb.TestName(id=117, builderid=88, name='name117'),
])
name_dicts = yield self.db.test_results.getTestNames(builderid=88)
self.assertEqual(
name_dicts,
['name103', 'name104', 'name105', 'name116', 'name117'])
name_dicts = yield self.db.test_results.getTestNames(
builderid=88, name_prefix='non_existing')
self.assertEqual(name_dicts, [])
name_dicts = yield self.db.test_results.getTestNames(
builderid=88, name_prefix='name10')
self.assertEqual(name_dicts, ['name103', 'name104', 'name105'])
name_dicts = yield self.db.test_results.getTestNames(
builderid=88, name_prefix='name11')
self.assertEqual(name_dicts, ['name116', 'name117'])
@defer.inlineCallbacks
def test_get_code_paths(self):
yield self.insertTestData(self.common_data + [
fakedb.TestCodePath(id=103, builderid=88, path='path103'),
fakedb.TestCodePath(id=104, builderid=88, path='path104'),
fakedb.TestCodePath(id=105, builderid=88, path='path105'),
fakedb.TestCodePath(id=116, builderid=88, path='path116'),
fakedb.TestCodePath(id=117, builderid=88, path='path117'),
])
path_dicts = yield self.db.test_results.getTestCodePaths(builderid=88)
self.assertEqual(
path_dicts,
['path103', 'path104', 'path105', 'path116', 'path117'])
path_dicts = yield self.db.test_results.getTestCodePaths(
builderid=88, path_prefix='non_existing')
self.assertEqual(path_dicts, [])
path_dicts = yield self.db.test_results.getTestCodePaths(
builderid=88, path_prefix='path10')
self.assertEqual(path_dicts, ['path103', 'path104', 'path105'])
path_dicts = yield self.db.test_results.getTestCodePaths(
builderid=88, path_prefix='path11')
self.assertEqual(path_dicts, ['path116', 'path117'])
