def test_really_fetch_sets_fetched_on_invalid_metadata(
self, get_implementation, __now__):
metadata = {"foo": "bar"}
tests = {"foo": "pass"}
metrics = {"bar": 1}
results = ('Complete', True, metadata, tests, metrics, "abc")
impl = MagicMock()
impl.fetch = MagicMock(return_value=results)
impl.job_url = MagicMock(return_value="http://www.example.com")
get_implementation.return_value = impl
environment = self.project.environments.create(slug='myenv')
self.build.test_runs.create(
environment=environment,
job_id='999',
job_status='Complete',
completed=True,
)
test_job = self.create_test_job(
backend=self.backend,
definition='foo: 1',
environment='myenv',
job_id='999',
)
self.backend.really_fetch(test_job)
self.assertTrue(test_job.fetched)
self.assertIsNotNone(test_job.failure)
def test_create_testrun_job_url(self, get_implementation, __now__):
metadata = {"foo": "bar"}
tests = {"foo": "pass"}
metrics = {"bar": 1}
results = ('Complete', True, metadata, tests, metrics, "abc")
test_job_url = "http://www.example.com"
impl = MagicMock()
impl.fetch = MagicMock(return_value=results)
impl.job_url = MagicMock(return_value=test_job_url)
get_implementation.return_value = impl
test_job = self.create_test_job(
backend=self.backend,
definition='foo: 1',
environment='myenv',
job_id='999',
)
self.backend.really_fetch(test_job)
# should not crash
test_run = core_models.TestRun.objects.get(
build__project=self.project,
environment__slug='myenv',
build__version='1',
job_id='999',
job_status='Complete',
completed=True,
)
self.assertEqual(test_run.job_url, test_job_url)
def test_fetch_with_only_metrics(self, get_implementation, __now__):
metadata = {"foo": "bar"}
tests = {}
metrics = {"foo": {"value": 10, "unit": "boxes"}}
results = ('Complete', True, metadata, tests, metrics, "abc")
impl = MagicMock()
impl.fetch = MagicMock(return_value=results)
impl.job_url = MagicMock(return_value="http://www.example.com")
get_implementation.return_value = impl
test_job = self.create_test_job(
backend=self.backend,
definition='foo: 1',
environment='myenv',
job_id='999',
)
self.backend.fetch(test_job.id)
# should not crash
test_run = core_models.TestRun.objects.get(
build__project=self.project,
environment__slug='myenv',
build__version='1',
job_id='999',
job_status='Complete',
)
test_job.refresh_from_db()
self.assertFalse(test_job.can_resubmit)
self.assertTrue(test_run.completed)
def test_really_fetch_sets_testjob_can_resubmit_and_testrun_completed2(
self, get_implementation, __now__):
metadata = {"foo": "bar"}
tests = {}
metrics = {}
results = ('Incomplete', False, metadata, tests, metrics, "abc")
# ^^^^^ job resulted in an infra failure
impl = MagicMock()
impl.fetch = MagicMock(return_value=results)
impl.job_url = MagicMock(return_value="http://www.example.com")
get_implementation.return_value = impl
test_job = self.create_test_job(
backend=self.backend,
definition='foo: 1',
environment='myenv',
job_id='999',
)
self.backend.really_fetch(test_job)
self.assertTrue(test_job.can_resubmit)
# should not crash
core_models.TestRun.objects.get(
build__project=self.project,
environment__slug='myenv',
build__version='1',
job_id='999',
job_status='Incomplete',
completed=False,
)
def test_get_listen_url(self):
backend = MagicMock()
backend.url = 'https://foo.tld/RPC2'
lava = LAVABackend(backend)
lava.__get_publisher_event_socket__ = MagicMock(return_value='tcp://bar.tld:9999')
self.assertEqual('tcp://bar.tld:9999', lava.get_listener_url())
lava.__get_publisher_event_socket__ = MagicMock(return_value='tcp://*:9999')
self.assertEqual('tcp://foo.tld:9999', lava.get_listener_url())
def test_resubmit_admin(self, get_implementation):
impl = MagicMock()
impl.resubmit = MagicMock()
get_implementation.return_value = impl
t = self.backend.test_jobs.create(target=self.project,
can_resubmit=True)
r = self.adminclient.post('/api/resubmit/%s' % t.pk)
self.assertEqual(201, r.status_code)
impl.resubmit.assert_called()
t.refresh_from_db()
self.assertEqual(False, t.can_resubmit)
def test_fetch_creates_testrun(self, get_implementation, __now__):
metadata = {"foo": "bar"}
tests = {"foo": "pass"}
metrics = {"bar": {"value": 1, "unit": ""}}
results = ('Complete', True, metadata, tests, metrics, "abc")
project_status = self.build.status
tests_pass_so_far = project_status.tests_pass
impl = MagicMock()
impl.fetch = MagicMock(return_value=results)
impl.job_url = MagicMock(return_value="http://www.example.com")
get_implementation.return_value = impl
test_job = self.create_test_job(
backend=self.backend,
definition='foo: 1',
environment='myenv',
job_id='999',
)
self.backend.fetch(test_job.id)
# should not crash
test_run = core_models.TestRun.objects.get(
build__project=self.project,
environment__slug='myenv',
build__version='1',
job_id='999',
job_status='Complete',
completed=True,
)
self.assertEqual(
1,
core_models.Test.objects.filter(
test_run=test_run,
metadata__name="foo",
result=True,
).count()
)
self.assertEqual(
1,
core_models.Metric.objects.filter(
test_run=test_run,
metadata__name="bar",
result=1,
).count()
)
project_status.refresh_from_db()
self.assertEqual(project_status.tests_pass, tests_pass_so_far + 1)
test_job.refresh_from_db()
self.assertTrue(test_job.fetched)
def test_submit(self, get_implementation):
test_job = self.create_test_job()
impl = MagicMock()
impl.submit = MagicMock(return_value=['999'])
get_implementation.return_value = impl
self.backend.submit(test_job)
test_job.refresh_from_db()
impl.submit.assert_called()
self.assertTrue(test_job.submitted)
self.assertIsNotNone(test_job.submitted_at)
self.assertEqual('999', test_job.job_id)
def test_really_fetch(self, get_implementation, __now__):
impl = MagicMock()
impl.fetch = MagicMock(return_value=None)
get_implementation.return_value = impl
test_job = self.create_test_job()
self.backend.really_fetch(test_job)
test_job.refresh_from_db()
self.assertEqual(NOW, test_job.last_fetch_attempt)
self.assertFalse(test_job.fetched)
get_implementation.assert_called()
impl.fetch.assert_called()
def test_resubmit_submitter_auth_token_cant_resubmit(
self, get_implementation):
impl = MagicMock()
impl.resubmit = MagicMock()
get_implementation.return_value = impl
t = self.backend.test_jobs.create(target=self.project,
can_resubmit=False)
r = self.restclient.post('/api/resubmit/%s' % t.pk)
self.assertEqual(403, r.status_code)
impl.resubmit.assert_not_called()
t.refresh_from_db()
self.assertEqual(False, t.can_resubmit)
def test_cancel(self, get_implementation):
test_job = models.TestJob.objects.create(target=self.project,
target_build=self.build,
environment='myenv',
backend=self.backend,
submitted=True,
job_id=123)
impl = MagicMock()
impl.cancel = MagicMock(return_value=True)
get_implementation.return_value = impl
test_job.cancel()
impl.cancel.assert_called()
def test_receive_event_no_testjob(self):
backend = MagicMock()
backend.url = 'https://foo.tld/RPC2'
lava = LAVABackend(backend)
# just not crashing is OK
lava.receive_event('foo.com.testjob', {})
def test_force_resubmit_submitter_token_auth(self, get_implementation):
impl = MagicMock()
impl.resubmit = MagicMock()
get_implementation.return_value = impl
t = self.backend.test_jobs.create(
target=self.project,
can_resubmit=True,
job_id="12345",
)
r = self.restclient.post('/api/resubmit/%s' % t.pk)
self.assertEqual(201, r.status_code)
impl.resubmit.assert_called()
t.refresh_from_db()
self.assertEqual(False, t.can_resubmit)
def test_receive_event_wrong_topic(self):
backend = MagicMock()
backend.url = 'https://foo.tld/RPC2'
lava = LAVABackend(backend)
# just not crashing is OK
lava.receive_event('foo.com.device', {'job': '123'})
def test_keep_listeners_running_changed(self, Popen):
manager = ListenerManager()
backend = Backend.objects.create(name="foo")
# start existing backends
manager.keep_listeners_running()
manager.stop = MagicMock()
manager.start = MagicMock()
# backend is changed
backend.name = 'bar'
backend.save()
manager.keep_listeners_running()
manager.stop.assert_called_with(backend.id)
manager.start.assert_called_with(backend)
def test_cancel_not_submitted(self, get_implementation):
test_job = models.TestJob.objects.create(target=self.project,
target_build=self.build,
environment='myenv',
backend=self.backend,
submitted=False)
impl = MagicMock()
impl.cancel = MagicMock(return_value=True)
get_implementation.return_value = impl
test_job.cancel()
impl.cancel.assert_not_called()
test_job.refresh_from_db()
self.assertTrue(test_job.fetched)
self.assertTrue(test_job.submitted)
self.assertIsNotNone(test_job.failure)
def test_keep_listeners_running_added(self, Popen):
manager = ListenerManager()
backend1 = Backend.objects.create(name="foo")
manager.start = MagicMock()
manager.stop = MagicMock()
# start existing backends
manager.keep_listeners_running()
manager.start.assert_called_with(backend1)
# new backend, start it too
backend2 = Backend.objects.create(name="bar")
manager.keep_listeners_running()
manager.start.assert_called_with(backend2)
manager.stop.assert_not_called()
def test_keep_listeners_running_restart_dead_process(self, Popen):
manager = ListenerManager()
backend = Backend.objects.create(name="foo")
# start existing backends
manager.keep_listeners_running()
self.assertEqual(1, len(manager.__processes__))
Popen.assert_called()
# "kill" the process
Popen.return_value.poll.return_value = -15 # SIGKILL
manager.stop = MagicMock()
manager.start = MagicMock()
# Give it another go
manager.keep_listeners_running()
manager.stop.assert_called_with(backend.id)
manager.start.assert_called_with(backend)
def test_cleanup(self, Popen):
backend1 = Backend.objects.create(name="foo")
backend2 = Backend.objects.create(name="bar")
manager = ListenerManager()
manager.start(backend1)
manager.start(backend2)
manager.stop = MagicMock()
manager.cleanup()
manager.stop.assert_has_calls(
[call(backend1.id), call(backend2.id)], any_order=True)
def test_fetch_ignores_results_from_incomplete_job(self,
get_implementation,
__now__):
metadata = {"foo": "bar"}
tests = {"foo": "pass"}
metrics = {"bar": {"value": 1, "unit": ""}}
results = ('Incomplete', False, metadata, tests, metrics, "abc")
# ^^^^^ job resulted in an infra failure
impl = MagicMock()
impl.fetch = MagicMock(return_value=results)
impl.job_url = MagicMock(return_value="http://www.example.com")
get_implementation.return_value = impl
test_job = self.create_test_job(
backend=self.backend,
definition='foo: 1',
environment='myenv',
job_id='999',
)
self.backend.fetch(test_job.id)
test_job.refresh_from_db()
self.assertTrue(test_job.can_resubmit)
# should not crash
testrun = core_models.TestRun.objects.get(
build__project=self.project,
environment__slug='myenv',
build__version='1',
job_id='999',
job_status='Incomplete',
completed=False, # even if results are not empty
)
# no results get recorded
self.assertEqual(0, testrun.tests.count())
self.assertEqual(0, testrun.metrics.count())
def test_keep_listeners_running_removed(self, Popen):
manager = ListenerManager()
backend = Backend.objects.create(name="foo")
manager.stop = MagicMock()
# start existing backends
manager.keep_listeners_running()
# backend is removed
bid = backend.id
backend.delete()
manager.keep_listeners_running()
manager.stop.assert_called_with(bid)
def test_resubmit(self, get_implementation):
impl = MagicMock()
impl.resubmit = MagicMock()
get_implementation.return_value = impl
t = self.backend.test_jobs.create(
target=self.project,
can_resubmit=True
)
staff_user_password = "******"
staff_user = User.objects.create_superuser(
username="******",
email="*****@*****.**",
password=staff_user_password,
is_staff=True)
staff_user.save()
client = Client()
client.login(username=staff_user.username, password=staff_user_password)
r = client.get('/api/resubmit/%s' % t.pk)
self.assertEqual(201, r.status_code)
impl.resubmit.assert_called()
t.refresh_from_db()
self.assertEqual(False, t.can_resubmit)
def test_automated_resubmit_email(self, get_results, get_details,
get_logs):
self.project.admin_subscriptions.create(email='*****@*****.**')
lava = LAVABackend(self.backend)
testjob = TestJob(job_id='1234',
backend=self.backend,
target=self.project)
resubmitted_job = TestJob(job_id='1235',
backend=self.backend,
target=self.project,
resubmitted_count=1)
resubmitted_job.save()
lava.resubmit = MagicMock(return_value=resubmitted_job)
status, completed, metadata, results, metrics, logs = lava.fetch(
testjob)
lava.resubmit.assert_called()
# there should be an admin email sent after resubmission
self.assertEqual(1, len(mail.outbox))
def test_run(self):
backend = MagicMock()
listener = Listener(backend)
listener.run()
backend.get_implementation.return_value.listen.assert_called_once()