def test_isRunning_timeout(self, mock_update):
job = Job(change_num="change_num", project_name="project")
job.node_ip = 'ip'
delta = datetime.timedelta(seconds=int(Configuration().MAX_RUNNING_TIME))
job.updated = datetime.datetime.now() - delta
self.assertFalse(job.isRunning("DB"))
mock_update.assert_called_with("DB", result='Aborted: Timed out')
def test_recent_jobs(self, now):
now.return_value = NOW
db = DB('sqlite://')
db.create_schema()
job1 = Job(change_num="change_num1", project_name="project")
job2 = Job(change_num="change_num2", project_name="project")
with db.get_session() as session:
session.add(job1)
job1.created=PAST
job1.db = db
job1.state=constants.RUNNING
job1.updated=PAST
session.add(job2)
recent_jobs = Job.getRecent(db)
self.assertEqual(len(recent_jobs), 1)
recent_jobs = Job.getRecent(db, 200000)
self.assertEqual(len(recent_jobs), 2)
def test_isRunning_pid_fail(self, mock_execute_command, mock_update):
job = Job(change_num="change_num", project_name="project")
job.node_ip = 'ip'
delta = datetime.timedelta(seconds=350)
job.updated = datetime.datetime.now() - delta
mock_execute_command.side_effect=Exception('SSH error getting PID')
self.assertFalse(job.isRunning("DB"))
mock_update.assert_called_with("DB", result='Aborted: Exception checking for pid')
self.assertEqual(1, mock_execute_command.call_count)
def test_runTest_deletes_bad_node(self, mock_getSSHObject, mock_update):
job = Job(change_num="change_num", project_name="project")
nodepool = mock.Mock()
nodepool.getNode.return_value = ('new_node', 'ip')
mock_getSSHObject.return_value = None
job.runJob("DB", nodepool)
nodepool.deleteNode.assert_called_once_with('new_node')
mock_update.assert_called_once_with("DB", node_id=0)
def test_runTest_deletes_existing_node(self, mock_getSSHObject, mock_update):
job = Job(change_num="change_num", project_name="project")
job.node_id='existing_node'
nodepool = mock.Mock()
nodepool.getNode.return_value = (None, None)
job.runJob("DB", nodepool)
nodepool.deleteNode.assert_called_once_with('existing_node')
mock_update.assert_called_once_with("DB", node_id=0)
self.assertEqual(0, mock_getSSHObject.call_count)
def addJob(self, change_ref, project_name, commit_id):
change_num = change_ref.split('/')[3]
existing_jobs = Job.retrieve(self.db, project_name, change_num)
for existing in existing_jobs:
self.log.info(
'Job for previous patchset (%s) already queued - replacing' %
(existing))
existing.update(self.db, state=constants.OBSOLETE)
job = Job(change_num, change_ref, project_name, commit_id)
with self.db.get_session() as session:
self.log.info("Job for %s queued" % job.change_num)
session.add(job)
def test_isRunning_happy_path(self, mock_execute_command, mock_update):
job = Job(change_num="change_num", project_name="project")
job.node_ip = 'ip'
delta = datetime.timedelta(seconds=350)
job.updated = datetime.datetime.now() - delta
mock_execute_command.return_value = False
self.assertFalse(job.isRunning("DB"))
self.assertEqual(0, mock_update.call_count)
mock_execute_command.return_value = True
self.assertTrue(job.isRunning("DB"))
self.assertEqual(0, mock_update.call_count)
def test_runTest_update_test_runner(self, mock_update_testrunner,
mock_execute_command,
mock_update, mock_sleep):
job = Job(change_num="change_num", change_ref='change_ref',
project_name="stackforge/xenapi-os-testing")
nodepool = mock.Mock()
nodepool.getNode.return_value = ('new_node', 'ip')
ssh = mock.Mock()
job.runJob("DB", nodepool)
mock_update_testrunner.assert_has_calls([mock.call('change_ref')])
def test_runTest_happy_path(self, mock_execute_command,
mock_update, mock_sleep):
job = Job(change_num="change_num", project_name="project")
nodepool = mock.Mock()
nodepool.getNode.return_value = ('new_node', 'ip')
ssh = mock.Mock()
job.runJob("DB", nodepool)
# The node should not be deleted(!)
self.assertEqual(0, nodepool.deleteNode.call_count)
# Two calls - one to set the node ID and the other to set the state to running
update_call1 = mock.call("DB", node_id='new_node', result='', node_ip='ip')
update_call2 = mock.call("DB", state=constants.RUNNING)
mock_update.assert_has_calls([update_call1, update_call2])
def test_delete(self):
db = DB('sqlite://')
db.create_schema()
job = Job(change_num="change_num", project_name="project")
with db.get_session() as session:
session.add(job)
job.db = db
jobs = Job.getAllWhere(db)
self.assertEqual(len(jobs), 1)
Job.deleteWhere(db)
jobs = Job.getAllWhere(db)
self.assertEqual(len(jobs), 0)
def test_start_test_clears_time(self, now):
now.return_value = NOW
db = DB('sqlite://')
db.create_schema()
job = Job(change_num="change_num", project_name="project")
with db.get_session() as session:
session.add(job)
job.created=PAST
job.db = db
job.update(db, state=constants.RUNNING)
with db.get_session() as session:
job, = session.query(Job).all()
self.assertEquals(job.updated, NOW)
self.assertEquals(job.state, constants.RUNNING)
self.assertEquals(job.test_started, NOW)
self.assertEquals(job.test_stopped, None)
self.assertEquals("project", job.project_name)
self.assertEquals("change_num", job.change_num)
def test_update(self, now):
now.return_value = NOW
db = DB('sqlite://')
db.create_schema()
job = Job(change_num="change_num", project_name="project")
with db.get_session() as session:
session.add(job)
job.created=PAST
job.db = db
self.assertEqual(job.state, constants.QUEUED)
job.update(db, state=constants.FINISHED)
with db.get_session() as session:
job, = session.query(Job).all()
self.assertEquals(NOW, job.updated)
self.assertEquals(constants.FINISHED, job.state)
self.assertEquals("project", job.project_name)
self.assertEquals("change_num", job.change_num)
def setUp(self):
self.job = Job()
def test_isRunning_early_wait(self):
job = Job(change_num="change_num", project_name="project")
job.node_ip = 'ip'
job.updated = datetime.datetime.now()
self.assertTrue(job.isRunning("DB"))
def test_isRunning_no_ip(self):
job = Job(change_num="change_num", project_name="project")
self.assertFalse(job.isRunning("DB"))
