#!/usr/bin/python2

"""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()