#!/usr/bin/python
|
|
"""Tests for drone_utility."""
|
|
import os
|
import unittest
|
|
import common
|
from autotest_lib.client.common_lib import autotemp
|
from autotest_lib.client.common_lib.test_utils import mock
|
from autotest_lib.scheduler import drone_utility
|
|
|
class TestProcessRefresher(unittest.TestCase):
|
"""Tests for the drone_utility.ProcessRefresher object."""
|
|
def setUp(self):
|
self._tempdir = autotemp.tempdir(unique_id='test_process_refresher')
|
self.addCleanup(self._tempdir.clean)
|
self._fake_command = '!faketest!'
|
self._fake_proc_info = {'pid': 3, 'pgid': 4, 'ppid': 2,
|
'comm': self._fake_command, 'args': ''}
|
self.god = mock.mock_god()
|
self.god.stub_function(drone_utility, '_get_process_info')
|
self._mock_get_process_info = drone_utility._get_process_info
|
self.god.stub_function(drone_utility, '_process_has_dark_mark')
|
self._mock_process_has_dark_mark = (
|
drone_utility._process_has_dark_mark)
|
|
|
def tearDown(self):
|
self.god.unstub_all()
|
|
def test_no_processes(self):
|
"""Sanity check the case when there is nothing to do"""
|
self._mock_get_process_info.expect_call().and_return([])
|
process_refresher = drone_utility.ProcessRefresher(check_mark=False)
|
got, warnings = process_refresher([])
|
expected = {
|
'pidfiles': dict(),
|
'all_processes': [],
|
'autoserv_processes': [],
|
'parse_processes': [],
|
'pidfiles_second_read': dict(),
|
}
|
self.god.check_playback()
|
self.assertEqual(got, expected)
|
|
|
def test_read_pidfiles_use_pool(self):
|
"""Readable subset of pidfile paths are included in the result
|
|
Uses process pools.
|
"""
|
self._parameterized_test_read_pidfiles(use_pool=True)
|
|
|
def test_read_pidfiles_no_pool(self):
|
"""Readable subset of pidfile paths are included in the result
|
|
Does not use process pools.
|
"""
|
self._parameterized_test_read_pidfiles(use_pool=False)
|
|
|
def test_read_many_pidfiles(self):
|
"""Read a large number of pidfiles (more than pool size)."""
|
self._mock_get_process_info.expect_call().and_return([])
|
expected_pidfiles = {}
|
for i in range(1000):
|
data = 'data number %d' % i
|
path = self._write_pidfile('pidfile%d' % i, data)
|
expected_pidfiles[path] = data
|
|
process_refresher = drone_utility.ProcessRefresher(check_mark=False,
|
use_pool=True)
|
got, _ = process_refresher(expected_pidfiles.keys())
|
expected = {
|
'pidfiles': expected_pidfiles,
|
'all_processes': [],
|
'autoserv_processes': [],
|
'parse_processes': [],
|
'pidfiles_second_read': expected_pidfiles,
|
}
|
self.god.check_playback()
|
self.assertEqual(got, expected)
|
|
|
def test_filter_processes(self):
|
"""Various filtered results correctly classify processes by name."""
|
self.maxDiff = None
|
process_refresher = drone_utility.ProcessRefresher(check_mark=False)
|
autoserv_processes = [self._proc_info_dict(3, 'autoserv')]
|
parse_processes = [self._proc_info_dict(4, 'parse'),
|
self._proc_info_dict(5, 'site_parse')]
|
all_processes = ([self._proc_info_dict(6, 'who_cares')]
|
+ autoserv_processes + parse_processes)
|
|
self._mock_get_process_info.expect_call().and_return(all_processes)
|
got, _warnings = process_refresher(self._tempdir.name)
|
expected = {
|
'pidfiles': dict(),
|
'all_processes': all_processes,
|
'autoserv_processes': autoserv_processes,
|
'parse_processes': parse_processes,
|
'pidfiles_second_read': dict(),
|
}
|
self.god.check_playback()
|
self.assertEqual(got, expected)
|
|
|
def test_respect_dark_mark(self):
|
"""When check_mark=True, dark mark check is performed and respected.
|
|
Only filtered processes with dark mark should be returned. We only test
|
this with use_pool=False because mocking out _process_has_dark_mark with
|
multiprocessing.Pool is hard.
|
"""
|
self.maxDiff = None
|
process_refresher = drone_utility.ProcessRefresher(check_mark=True)
|
marked_process = self._proc_info_dict(3, 'autoserv')
|
unmarked_process = self._proc_info_dict(369, 'autoserv')
|
all_processes = [marked_process, unmarked_process]
|
self._mock_get_process_info.expect_call().and_return(all_processes)
|
self._mock_process_has_dark_mark.expect_call(3).and_return(True)
|
self._mock_process_has_dark_mark.expect_call(369).and_return(False)
|
got, warnings = process_refresher(self._tempdir.name)
|
expected = {
|
'pidfiles': dict(),
|
'all_processes': all_processes,
|
'autoserv_processes': [marked_process],
|
'parse_processes': [],
|
'pidfiles_second_read': dict(),
|
}
|
self.god.check_playback()
|
self.assertEqual(got, expected)
|
self.assertEqual(len(warnings), 1)
|
self.assertRegexpMatches(warnings[0], '.*autoserv.*369.*')
|
|
|
def _parameterized_test_read_pidfiles(self, use_pool):
|
"""Readable subset of pidfile paths are included in the result
|
|
@param: use_pool: Argument use_pool for ProcessRefresher
|
"""
|
self._mock_get_process_info.expect_call().and_return([])
|
path1 = self._write_pidfile('pidfile1', 'first pidfile')
|
path2 = self._write_pidfile('pidfile2', 'second pidfile',
|
subdir='somedir')
|
process_refresher = drone_utility.ProcessRefresher(check_mark=False,
|
use_pool=use_pool)
|
got, warnings = process_refresher(
|
[path1, path2,
|
os.path.join(self._tempdir.name, 'non_existent')])
|
expected_pidfiles = {
|
path1: 'first pidfile',
|
path2: 'second pidfile',
|
}
|
expected = {
|
'pidfiles': expected_pidfiles,
|
'all_processes': [],
|
'autoserv_processes': [],
|
'parse_processes': [],
|
'pidfiles_second_read': expected_pidfiles,
|
}
|
self.god.check_playback()
|
self.assertEqual(got, expected)
|
|
|
def _write_pidfile(self, filename, content, subdir=''):
|
parent_dir = self._tempdir.name
|
if subdir:
|
parent_dir = os.path.join(parent_dir, subdir)
|
os.makedirs(parent_dir)
|
path = os.path.join(parent_dir, filename)
|
with open(path, 'w') as f:
|
f.write(content)
|
return path
|
|
def _proc_info_dict(self, pid, comm, pgid=33, ppid=44, args=''):
|
return {'pid': pid, 'comm': comm, 'pgid': pgid, 'ppid': ppid,
|
'args': args}
|
|
|
if __name__ == '__main__':
|
unittest.main()
|
