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)
def test_build_status_failed(self):
r = Run(self.build, 'name1')
r.status = BuildStatus.PASSED
db.session.add(r)
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.FAILED, self.build.status)
self.assertEqual(['QUEUED', 'FAILED'],
[x.status.name for x in self.build.status_events])
def test_build_complete_email_skip(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": "*****@*****.**",
"only_failures": True,
},
},
],
})
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([], build_complete.call_args_list)
# now fail the run and make sure we get notified
r.status = BuildStatus.RUNNING
db.session.commit()
headers = [
("Authorization", "Token %s" % r.api_key),
("X-RUN-STATUS", "FAILED"),
]
self._post(self.urlbase + "run0/", None, headers, 200)
db.session.refresh(r)
self.assertEqual(self.build, build_complete.call_args_list[0][0][0])
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_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_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_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_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_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_health(self):
self.create_projects("proj-1")
p = Project.query.first()
b = Build.create(p)
db.session.add(Run(b, "queued-1"))
db.session.add(Run(b, "queued-2"))
w1 = Worker("worker1", "distro", 12, 12, "amd", "key", 2, "tag")
db.session.add(w1)
w2 = Worker("worker2", "distro", 12, 12, "amd", "key", 2, "tag")
db.session.add(w2)
db.session.flush()
r = Run(b, "run1-worker1")
r.worker = w1
r.status = BuildStatus.UPLOADING
db.session.add(r)
r = Run(b, "run1-worker2")
r.worker = w2
r.status = BuildStatus.RUNNING
db.session.add(r)
r = Run(b, "run2-worker2")
r.worker = w2
r.status = BuildStatus.RUNNING
db.session.add(r)
r = Run(b, "run3rworker2")
r.worker = w2
r.status = BuildStatus.CANCELLING
db.session.add(r)
db.session.commit()
r = self.client.get("/health/runs/")
self.assertEqual(200, r.status_code)
d = json.loads(r.data.decode())["data"]
self.assertEqual(2, d["health"]["statuses"]["QUEUED"])
self.assertEqual(2, d["health"]["statuses"]["RUNNING"])
self.assertEqual(1, d["health"]["statuses"]["UPLOADING"])
self.assertEqual(1, len(d["health"]["RUNNING"]["worker1"]))
self.assertEqual(3, len(d["health"]["RUNNING"]["worker2"]))
self.assertEqual(2, len(d["health"]["QUEUED"]))
def test_run_health(self):
self.create_projects('proj-1')
p = Project.query.first()
b = Build.create(p)
db.session.add(Run(b, 'queued-1'))
db.session.add(Run(b, 'queued-2'))
w1 = Worker('worker1', 'distro', 12, 12, 'amd', 'key', 2, 'tag')
db.session.add(w1)
w2 = Worker('worker2', 'distro', 12, 12, 'amd', 'key', 2, 'tag')
db.session.add(w2)
db.session.flush()
r = Run(b, 'run1-worker1')
r.worker = w1
r.status = BuildStatus.UPLOADING
db.session.add(r)
r = Run(b, 'run1-worker2')
r.worker = w2
r.status = BuildStatus.RUNNING
db.session.add(r)
r = Run(b, 'run2-worker2')
r.worker = w2
r.status = BuildStatus.RUNNING
db.session.add(r)
r = Run(b, 'run3rworker2')
r.worker = w2
r.status = BuildStatus.CANCELLING
db.session.add(r)
db.session.commit()
r = self.client.get('/health/runs/')
self.assertEqual(200, r.status_code)
d = json.loads(r.data.decode())['data']
self.assertEqual(2, d['health']['statuses']['QUEUED'])
self.assertEqual(2, d['health']['statuses']['RUNNING'])
self.assertEqual(1, d['health']['statuses']['UPLOADING'])
self.assertEqual(1, len(d['health']['RUNNING']['worker1']))
self.assertEqual(3, len(d['health']['RUNNING']['worker2']))
self.assertEqual(2, len(d['health']['QUEUED']))
def test_project_run_history(self):
self.create_projects("proj-1")
p = Project.query.all()[0]
for x in range(4):
b = Build.create(p)
r = Run(b, "run0")
r.status = BuildStatus.PASSED
if x % 2 == 0:
r.status = BuildStatus.FAILED
db.session.add(r)
r = Run(b, "run1")
db.session.add(r)
db.session.commit()
r = self.get_json("/projects/proj-1/history/run0/")
expected = ["PASSED", "FAILED", "PASSED", "FAILED"]
self.assertEqual(expected, [x["status"] for x in r["runs"]])
expected = ["run0", "run0", "run0", "run0"]
self.assertEqual(expected, [x["name"] for x in r["runs"]])
def test_project_run_history(self):
self.create_projects('proj-1')
p = Project.query.all()[0]
for x in range(4):
b = Build.create(p)
r = Run(b, 'run0')
r.status = BuildStatus.PASSED
if x % 2 == 0:
r.status = BuildStatus.FAILED
db.session.add(r)
r = Run(b, 'run1')
db.session.add(r)
db.session.commit()
r = self.get_json('/projects/proj-1/history/run0/')
expected = ['PASSED', 'FAILED', 'PASSED', 'FAILED']
self.assertEqual(expected, [x['status'] for x in r['runs']])
expected = ['run0', 'run0', 'run0', 'run0']
self.assertEqual(expected, [x['name'] for x in r['runs']])
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_upload(self, storage):
r = Run(self.build, 'run0')
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [('Authorization', 'Token %s' % r.api_key)]
storage.generate_signed.return_value = {
'foo': 'bar',
'blah': 'bam',
}
url = self.urlbase + 'run0/create_signed'
uploads = json.dumps(['foo', 'bar'])
self._post(url, uploads, headers, 200)
def test_upload(self, storage):
r = Run(self.build, "run0")
r.status = BuildStatus.RUNNING
db.session.add(r)
db.session.commit()
headers = [("Authorization", "Token %s" % r.api_key)]
storage.generate_signed.return_value = {
"foo": "bar",
"blah": "bam",
}
url = self.urlbase + "run0/create_signed"
uploads = json.dumps(["foo", "bar"])
self._post(url, uploads, headers, 200)
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_worker_sync_builds_uploading(self, storage):
"""Make sure scheduler takes into account runs that are UPLOADING.
1. Create a "synchronous" Project
2. Add an UPLOADING build and and QUEUED build
Make sure the QUEUED build is not assigned
"""
if db.engine.dialect.name == "sqlite":
self.skipTest("Test requires MySQL")
rundef = {"run_url": "foo", "runner_url": "foo", "env": {}}
storage().get_run_definition.return_value = json.dumps(rundef)
w = Worker("w1", "ubuntu", 12, 2, "aarch64", "key", 2, ["aarch96"])
w.enlisted = True
w.online = True
db.session.add(w)
self.create_projects("job-1")
(p1, ) = Project.query.all()
p1.synchronous_builds = True
db.session.commit()
# add active build
b = Build.create(p1)
r = Run(b, "p1b1r1")
r.status = BuildStatus.UPLOADING
r.host_tag = "aarch96"
db.session.add(r)
b = Build.create(p1)
r = Run(b, "p1b2r1")
r.host_tag = "aarch96"
db.session.add(r)
db.session.commit()
headers = [
("Content-type", "application/json"),
("Authorization", "Token key"),
]
qs = "available_runners=1&foo=2"
# There should be no work available
resp = self.client.get("/workers/w1/",
headers=headers,
query_string=qs)
self.assertEqual(200, resp.status_code, resp.data)
data = json.loads(resp.data.decode())
self.assertNotIn("run-defs", data["data"]["worker"],
data["data"]["worker"])
