def test_build_complete_email(self, build_complete, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'triggers': [
{
'name': 'github',
'type': 'github_pr',
'runs': [{
'name': 'run0',
}],
'email': {
'users': '*****@*****.**',
}
},
],
})
m.console_logfd.return_value = open('/dev/null', 'w')
m.get_run_definition.return_value = json.dumps({})
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'github'
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', None, headers, 200)
db.session.refresh(r)
self.assertEqual(self.build, build_complete.call_args_list[0][0][0])
self.assertEqual('*****@*****.**', build_complete.call_args_list[0][0][1])
def test_build_complete_lava_tests(self, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'triggers': [
{
'name': 'github',
'type': 'github_pr',
'runs': [{
'name': 'run0',
}],
},
],
})
m.console_logfd.return_value = open('/dev/null', 'w')
m.get_run_definition.return_value = json.dumps({})
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'github'
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
db.session.add(Test(r, 'test-1', 'ctx', BuildStatus.QUEUED))
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', None, headers, 200)
db.session.refresh(r)
self.assertEqual(BuildStatus.RUNNING, r.status)
def test_promote_post(self):
b = Build.create(self.project)
db.session.add(Run(b, "run0"))
db.session.add(Run(b, "run1"))
url = "http://localhost/projects/proj-1/builds/%d/promote" % b.build_id
headers = {
"Content-type": "application/json",
}
data = {
"name": "release-x",
"annotation": "foo bar",
}
# you can't promote an in-progress build
_sign(url, headers, "POST")
self._post(url, json.dumps(data), headers, 400)
for r in b.runs:
r.set_status(BuildStatus.PASSED)
self._post(url, json.dumps(data), headers, 201)
db.session.refresh(b)
self.assertEqual(BuildStatus.PROMOTED, b.status)
self.assertEqual(data["name"], b.name)
self.assertEqual(data["annotation"], b.annotation)
def _fail_unexpected(build, exception):
r = Run(build, "build-failure")
db.session.add(r)
r.set_status(BuildStatus.FAILED)
db.session.commit()
storage = Storage()
with storage.console_logfd(r, "a") as f:
f.write("Unexpected error prevented build from running:\n")
f.write(str(exception))
storage.copy_log(r)
if BUILD_URL_FMT:
url = BUILD_URL_FMT.format(project=build.project.name,
build=build.build_id)
else:
url = url_for(
"api_run.run_get_artifact",
proj=build.project.name,
build_id=build.build_id,
run=r.name,
path="console.log",
)
exception = ApiError(500, str(exception))
exception.resp.headers.extend({"Location": url})
return exception
def test_stuck(self, update_run, notify):
"""Ensure stuck runs are failed."""
self.create_projects('proj1')
b = Build.create(Project.query.all()[0])
r = Run(b, 'bla')
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
e = RunEvents(r, BuildStatus.RUNNING)
e.time = datetime.datetime.utcnow() - datetime.timedelta(hours=13)
db.session.add(e)
db.session.commit()
_check_stuck()
self.assertEqual('bla', notify.call_args[0][0].name)
notify.rest_mock()
r.status = BuildStatus.CANCELLING
e = RunEvents(r, BuildStatus.RUNNING)
e.time = datetime.datetime.utcnow() - datetime.timedelta(hours=13)
db.session.add(e)
db.session.commit()
_check_stuck()
self.assertEqual('bla', notify.call_args[0][0].name)
self.assertEqual('bla', update_run.call_args[0][0].name)
class SendmailTest(JobServTest):
def setUp(self):
super().setUp()
self.create_projects("job-1")
self.proj = Project.query.filter_by(name="job-1").first_or_404()
self.build = Build.create(self.proj)
self.run = Run(self.build, "run-name")
db.session.add(self.run)
self.run.set_status(BuildStatus.FAILED)
@patch("jobserv.notify.smtplib")
def test_notify_build_complete(self, smtplib):
smtplib.SMTP().starttls.return_value = (220, b"ok")
smtplib.SMTP().login.return_value = (235, b"ok")
notify_build_complete_email(self.build, "*****@*****.**")
msg = smtplib.SMTP().send_message.call_args_list[0][0][0]
self.assertEqual("jobserv: job-1 build #1 : FAILED", msg["Subject"])
self.assertIn("\n run-name: FAILED", msg.get_payload())
def test_get_build_stats(self):
# we already have one build created from constructor
for i in range(9):
b = Build.create(self.proj)
r = Run(b, "run-name")
db.session.add(r)
if i % 2:
r.set_status(BuildStatus.FAILED)
else:
r.set_status(BuildStatus.PASSED)
db.session.commit()
stats = _get_build_stats(b)
self.assertEqual(10, stats["total"])
self.assertEqual(5, stats["passes"])
self.assertEqual(50, stats["pass_rate"])
def test_build_complete(self, webhook, build_complete_email, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
"timeout":
5,
"triggers": [
{
"name":
"github",
"type":
"github_pr",
"runs": [{
"name": "run0",
}],
"email": {
"users": "*****@*****.**",
},
"webhooks": [
{
"url": "https://example.com",
"secret_name": "example_secret",
},
],
},
],
})
m.console_logfd.return_value = open("/dev/null", "w")
m.get_run_definition.return_value = json.dumps(
{"secrets": {
"example_secret": "secret_value"
}})
storage.return_value = m
r = Run(self.build, "run0")
r.trigger = "github"
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
("Authorization", "Token %s" % r.api_key),
("X-RUN-STATUS", "PASSED"),
]
self._post(self.urlbase + "run0/", None, headers, 200)
db.session.refresh(r)
build_complete_email.assert_called_with(self.build, "*****@*****.**")
# dumb but its notified from a thread
sleep(0.1)
webhook.post.assert_called_once()
call = webhook.post.call_args_list[0]
self.assertEqual("https://example.com", call[0][0])
sig = call[1]["headers"]["X-JobServ-Sig"]
data = call[1]["data"]
self.assertEqual("sha256:", sig[:7])
computed = hmac.new(b"secret_value", data.encode(),
"sha256").hexdigest()
self.assertTrue(hmac.compare_digest(computed, sig[7:]))
self.assertIn("reason", data)
def test_build_complete_lava_tests(self, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
"timeout":
5,
"triggers": [
{
"name": "github",
"type": "github_pr",
"runs": [{
"name": "run0",
}],
},
],
})
m.console_logfd.return_value = open("/dev/null", "w")
m.get_run_definition.return_value = json.dumps({})
storage.return_value = m
r = Run(self.build, "run0")
r.trigger = "github"
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
db.session.add(Test(r, "test-1", "ctx", BuildStatus.QUEUED))
db.session.commit()
headers = [
("Authorization", "Token %s" % r.api_key),
("X-RUN-STATUS", "PASSED"),
]
self._post(self.urlbase + "run0/", None, headers, 200)
db.session.refresh(r)
self.assertEqual(BuildStatus.RUNNING, r.status)
def test_promote_post(self):
b = Build.create(self.project)
db.session.add(Run(b, 'run0'))
db.session.add(Run(b, 'run1'))
url = 'http://localhost/projects/proj-1/builds/%d/promote' % b.build_id
headers = {
'Content-type': 'application/json',
}
data = {
'name': 'release-x',
'annotation': 'foo bar',
}
# you can't promote an in-progress build
_sign(url, headers, 'POST')
self._post(url, json.dumps(data), headers, 400)
for r in b.runs:
r.set_status(BuildStatus.PASSED)
self._post(url, json.dumps(data), headers, 201)
db.session.refresh(b)
self.assertEqual(BuildStatus.PROMOTED, b.status)
self.assertEqual(data['name'], b.name)
self.assertEqual(data['annotation'], b.annotation)
def test_run_complete_tests(self, storage):
# Same as test_run_complete_tests_default but with a test name pattern
m = Mock()
m.get_project_definition.return_value = json.dumps({
"timeout":
5,
"triggers": [
{
"name": "github",
"type": "github_pr",
"runs": [{
"name": "run0",
}],
},
],
})
@contextlib.contextmanager
def _logfd(run, mode="r"):
path = os.path.join(jobserv.storage.base.JOBS_DIR, run.name)
with open(path, mode) as f:
yield f
m.console_logfd = _logfd
data = """
t1: PASSED
t2: FAILED
Starting Test: TNAME...
t3: foo
"""
rundef = {
"test-grepping": {
"test-pattern": r".*Starting Test: (?P<name>\S+)...",
"result-pattern": r"\s*(?P<name>\S+): "
"(?P<result>(PASSED|FAILED|foo))",
"fixupdict": {
"foo": "PASSED"
},
}
}
m.get_run_definition.return_value = json.dumps(rundef)
storage.return_value = m
r = Run(self.build, "run0")
r.trigger = "github"
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
("Authorization", "Token %s" % r.api_key),
("X-RUN-STATUS", "PASSED"),
]
self._post(self.urlbase + "run0/", data, headers, 200)
tests = [(x.name, x.status.name) for x in Test.query.all()]
self.assertEqual([("default", "FAILED"), ("TNAME", "PASSED")], tests)
results = [(x.name, x.status.name)
for x in Test.query.all()[0].results]
expected = [("t1", "PASSED"), ("t2", "FAILED")]
self.assertEqual(expected, results)
def test_build_status_queued(self):
db.session.add(Run(self.build, 'name1'))
db.session.add(Run(self.build, 'name2'))
db.session.commit()
db.session.refresh(self.build)
self.build.refresh_status()
self.assertEqual(BuildStatus.QUEUED, self.build.status)
def test_run_complete_triggers_type_upgrade(self, storage):
""" We have a build that's triggered by either a github_pr or a
gitlab_mr. They might have runs that trigger something of type
"simple". This could be the case where a git_poller and github_mr
both trigger a similar set of tests *after* a build. In the
case of the github_pr, we should "upgrade" the type of each run
from simple to github_pr so that it can update the status of the
PR.
"""
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'triggers': [
{
'name': 'github',
'type': 'github_pr',
'runs': [{
'name': 'run0',
'host-tag': 'foo*',
'triggers': [
{'name': 'triggered', 'run-names': '{name}-run0'}
]
}],
},
{
'name': 'triggered',
'type': 'simple',
'runs': [{
'name': 'test',
'host-tag': 'bar',
'container': 'container-foo',
'script': 'test',
}],
},
],
'scripts': {
'test': '#test#',
}
})
m.console_logfd.return_value = open('/dev/null', 'w')
m.get_run_definition.return_value = json.dumps({})
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'github'
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', None, headers, 200)
run = Run.query.all()[1]
self.assertEqual('test-run0', run.name)
rundef = json.loads(m.set_run_definition.call_args_list[0][0][1])
self.assertEqual('github_pr', rundef['trigger_type'])
def test_run_list(self):
db.session.add(Run(self.build, "run0"))
db.session.add(Run(self.build, "run1"))
runs = self.get_json(self.urlbase)["runs"]
self.assertEqual(2, len(runs))
for i, r in enumerate(runs):
self.assertEqual("run%d" % i, r["name"])
self.assertEqual("QUEUED", r["status"])
def test_promote_list_empty(self, storage):
b = Build.create(self.project)
db.session.add(Run(b, 'run0'))
db.session.add(Run(b, 'run1'))
for r in b.runs:
r.set_status(BuildStatus.PASSED)
url = '/projects/%s/promoted-builds/' % self.project.name
builds = self.get_json(url)['builds']
self.assertEqual(0, len(builds))
def setUp(self):
super().setUp()
self.create_projects("job-1")
self.proj = Project.query.filter_by(name="job-1").first_or_404()
self.build = Build.create(self.proj)
self.run = Run(self.build, "run-name")
db.session.add(self.run)
self.run.set_status(BuildStatus.FAILED)
def test_build_status_passed(self):
r = Run(self.build, 'name')
r.status = BuildStatus.PASSED
db.session.add(r)
db.session.commit()
db.session.refresh(self.build)
self.build.refresh_status()
self.assertEqual(BuildStatus.PASSED, self.build.status)
def test_run_list(self):
db.session.add(Run(self.build, 'run0'))
db.session.add(Run(self.build, 'run1'))
runs = self.get_json(self.urlbase)['runs']
self.assertEqual(2, len(runs))
for i, r in enumerate(runs):
self.assertEqual('run%d' % i, r['name'])
self.assertEqual('QUEUED', r['status'])
def test_run_complete_triggers(self, build_complete, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'email': {
'users': '*****@*****.**',
},
'triggers': [
{
'name': 'git',
'type': 'git_poller',
'runs': [{
'name': 'run0',
'host-tag': 'foo*',
'triggers': [
{'name': 'triggered', 'run-names': '{name}-run0'}
]
}],
},
{
'name': 'triggered',
'type': 'simple',
'runs': [{
'name': 'test',
'host-tag': 'bar',
'container': 'container-foo',
'script': 'test',
}],
},
],
'scripts': {
'test': '#test#',
}
})
m.console_logfd.return_value = open('/dev/null', 'w')
m.get_run_definition.return_value = json.dumps({})
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'git'
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', None, headers, 200)
run = Run.query.all()[1]
self.assertEqual('test-run0', run.name)
self.assertEqual('QUEUED', run.status.name)
rundef = json.loads(m.set_run_definition.call_args_list[0][0][1])
self.assertEqual('git_poller', rundef['trigger_type'])
# Make sure we didn't send the email since the build isn't complete yet
self.assertEqual(0, build_complete.call_count)
def test_build_status_running(self):
db.session.add(Run(self.build, 'name1'))
r = Run(self.build, 'name2')
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
db.session.refresh(self.build)
self.build.refresh_status()
self.assertEqual(BuildStatus.RUNNING, self.build.status)
def test_build_status_running_failed(self):
db.session.add(Run(self.build, 'name1'))
r = Run(self.build, 'name2')
r.status = BuildStatus.FAILED
db.session.add(r)
db.session.commit()
db.session.refresh(self.build)
self.build.refresh_status()
self.assertEqual(BuildStatus.RUNNING_WITH_FAILURES, self.build.status)
def test_run_complete_tests(self, storage):
# Same as test_run_complete_tests_default but with a test name pattern
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'triggers': [
{
'name': 'github',
'type': 'github_pr',
'runs': [{
'name': 'run0',
}],
},
],
})
@contextlib.contextmanager
def _logfd(run, mode='r'):
path = os.path.join(jobserv.storage.base.JOBS_DIR, run.name)
with open(path, mode) as f:
yield f
m.console_logfd = _logfd
data = """
t1: PASSED
t2: FAILED
Starting Test: TNAME...
t3: foo
"""
rundef = {
'test-grepping': {
'test-pattern': '.*Starting Test: (?P<name>\S+)...',
'result-pattern': '\s*(?P<name>\S+): '
'(?P<result>(PASSED|FAILED|foo))',
'fixupdict': {'foo': 'PASSED'},
}
}
m.get_run_definition.return_value = json.dumps(rundef)
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'github'
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', data, headers, 200)
tests = [(x.name, x.status.name) for x in Test.query.all()]
self.assertEqual([('default', 'FAILED'), ('TNAME', 'PASSED')], tests)
results = [(x.name, x.status.name)
for x in Test.query.all()[0].results]
expected = [('t1', 'PASSED'), ('t2', 'FAILED')]
self.assertEqual(expected, results)
def test_build_complete_triggers(self, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'triggers': [
{
'name': 'github',
'type': 'github_pr',
'runs': [{
'name': 'run0',
'host-tag': 'foo*',
}],
'triggers': [
{'name': 'build-trigger'},
]
},
{
'name': 'build-trigger',
'type': 'simple',
'runs': [{
'name': 'test',
'host-tag': 'foo*',
'container': 'container-foo',
'script': 'test',
}],
},
],
'scripts': {
'test': '#test#',
}
})
m.console_logfd.return_value = open('/dev/null', 'w')
m.get_run_definition.return_value = json.dumps({})
m.get_build_params.return_value = {'buildparam': '42'}
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'github'
r.status = BuildStatus.RUNNING
r.queue_priority = 8675309
db.session.add(r)
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', None, headers, 200)
db.session.refresh(r)
run = Run.query.all()[1]
self.assertEqual('test', run.name)
self.assertEqual('QUEUED', run.status.name)
rundef = json.loads(m.set_run_definition.call_args[0][1])
self.assertEqual('42', rundef['env']['buildparam'])
self.assertEqual(8675309, run.queue_priority)
def test_build_complete(self, webhook, build_complete_email, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
'timeout': 5,
'triggers': [
{
'name': 'github',
'type': 'github_pr',
'runs': [{
'name': 'run0',
}],
'email': {
'users': '*****@*****.**',
},
'webhooks': [
{
'url': 'https://example.com',
'secret_name': 'example_secret',
},
],
},
],
})
m.console_logfd.return_value = open('/dev/null', 'w')
m.get_run_definition.return_value = json.dumps(
{'secrets': {'example_secret': 'secret_value'}})
storage.return_value = m
r = Run(self.build, 'run0')
r.trigger = 'github'
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [
('Authorization', 'Token %s' % r.api_key),
('X-RUN-STATUS', 'PASSED'),
]
self._post(self.urlbase + 'run0/', None, headers, 200)
db.session.refresh(r)
build_complete_email.assert_called_with(self.build, '*****@*****.**')
# dumb but its notified from a thread
sleep(0.1)
webhook.post.assert_called_once()
call = webhook.post.call_args_list[0]
self.assertEqual('https://example.com', call[0][0])
sig = call[1]['headers']['X-JobServ-Sig']
data = call[1]['data']
self.assertEqual('sha256:', sig[:7])
computed = hmac.new(
b'secret_value', data.encode(), 'sha256').hexdigest()
self.assertTrue(hmac.compare_digest(computed, sig[7:]))
def test_run_complete_triggers_name_error(self, storage):
m = Mock()
m.get_project_definition.return_value = json.dumps({
"timeout":
5,
"triggers": [
{
"name":
"github",
"type":
"github_pr",
"runs": [{
"name": "run0",
"host-tag": "foo*",
"triggers": [{
"name": "triggered"
}],
}],
},
{
"name":
"triggered",
"type":
"simple",
"runs": [{
"name": "collision-name",
"host-tag": "bar",
"container": "container-foo",
"script": "test",
}],
},
],
"scripts": {
"test": "#test#",
},
})
m.console_logfd.return_value = open("/dev/null", "w")
m.get_run_definition.return_value = json.dumps({})
m.get_artifact_content.return_value = "#mocked line 1\n"
storage.return_value = m
r = Run(self.build, "run0")
r.trigger = "github"
r.status = BuildStatus.RUNNING
db.session.add(r)
# cause a duplicate name collision
db.session.add(Run(self.build, "collision-name"))
db.session.commit()
headers = [
("Authorization", "Token %s" % r.api_key),
("X-RUN-STATUS", "PASSED"),
]
self._post(self.urlbase + "run0/", None, headers, 200)
self.assertEqual("RUNNING_WITH_FAILURES", r.build.status.name)
def test_get_stream(self, storage):
r = Run(self.build, 'run0')
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
with Storage().console_logfd(r, 'ab') as f:
f.write(b'this is the message')
resp = self.client.get(self.urlbase + 'run0/console.log')
self.assertEqual(200, resp.status_code)
self.assertEqual('text/plain', resp.mimetype)
def test_get_stream(self, storage):
r = Run(self.build, "run0")
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
with Storage().console_logfd(r, "ab") as f:
f.write(b"this is the message")
resp = self.client.get(self.urlbase + "run0/console.log")
self.assertEqual(200, resp.status_code)
self.assertEqual("text/plain", resp.mimetype)
def test_cancelled(self, update):
"""Ensure runs that were cancelled before they were assigned to a
worker are failed."""
self.create_projects('proj1')
b = Build.create(Project.query.all()[0])
r = Run(b, 'bla')
r.status = BuildStatus.CANCELLING
db.session.add(r)
db.session.commit()
_check_cancelled()
self.assertEqual('FAILED', update.call_args[1]['status'])
def test_run_rerun(self):
r = Run(self.build, 'run0')
r.status = BuildStatus.FAILED
db.session.add(r)
db.session.commit()
url = 'http://localhost' + self.urlbase + 'run0/rerun'
headers = {}
self._post(url, 'message', headers, 401)
permissions._sign(url, headers, 'POST')
self._post(url, 'message', headers, 200)
def test_run_rerun(self):
r = Run(self.build, "run0")
r.status = BuildStatus.FAILED
db.session.add(r)
db.session.commit()
url = "http://localhost" + self.urlbase + "run0/rerun"
headers = {}
self._post(url, "message", headers, 401)
permissions._sign(url, headers, "POST")
self._post(url, "message", headers, 200)
def test_as_json(self):
import jobserv.models
orig = jobserv.models.RUN_URL_FMT
r = Run(self.build, 'name1')
db.session.add(r)
db.session.commit()
try:
jobserv.models.RUN_URL_FMT = 'bar {build} | {run} | {project}'
Build.create(self.proj)
data = r.as_json()
self.assertEqual('bar 1 | name1 | job-1', data['web_url'])
finally:
jobserv.models.BUILD_URL_FMT = orig
