def test_main_some_args(self):
reloader = MockReloader('example_service.standalone', ['pysoa'])
mock_func = mock.MagicMock()
# noinspection PyUnresolvedReferences
with mock.patch.object(
target=reloader,
attribute='watch_and_reload') as mock_watch_and_reload:
reloader.main(mock_func, ('a', 'b'), {'c': 'd'})
mock_watch_and_reload.assert_called_once_with(
mock_func, ('a', 'b'), {'c': 'd'})
self.assertFalse(mock_func.called)
def test_only_file_watcher_argument_no_values(self, mock_get_reloader):
server_getter = mock.MagicMock()
sys.argv = [
'/path/to/example_service/standalone.py', '--use-file-watcher'
]
standalone.simple_main(server_getter)
server_getter.assert_called_once_with()
self.assertFalse(server_getter.return_value.main.called)
mock_get_reloader.assert_called_once_with('', None, signal_forks=False)
self.assertEqual(1, mock_get_reloader.return_value.main.call_count)
self.assertEqual(
server_getter.return_value,
mock_get_reloader.return_value.main.call_args_list[0][0][1][1],
)
def _start_patches(test_target):
if 'mock_patches' in test_target:
for mock_target, config in six.iteritems(test_target['mock_patches']):
config['patcher'] = unittest_mock.patch(mock_target, new=unittest_mock.MagicMock())
config['magic_mock'] = config['patcher'].start()
if config['configure']:
# The code in this came, and is slightly modified, from unittest.mock.Mock
# "We sort on the number of dots so that attributes are set before we set attributes on attributes"
for path, value in sorted(config['configure'].items(), key=lambda e: e[0].count('.')):
paths = path.split('.')
final = paths.pop()
obj = config['magic_mock']
for entry in paths:
obj = getattr(obj, entry)
if value is _DELETE_ATTRIBUTE:
delattr(obj, final)
else:
setattr(obj, final, value)
def test_watch_and_reload_for_restart(self, mock_sys, mock_os):
reloader = MockReloader('example_service.standalone', ['pysoa'])
mock_func = mock.MagicMock()
# noinspection PyUnresolvedReferences
with mock.patch.object(target=reloader, attribute='restart_with_reloader') as mock_restart_with_reloader,\
mock.patch.object(target=reloader, attribute='watch_files') as mock_watch_files,\
mock.patch.object(target=reloader, attribute='stop_watching') as mock_stop_watching:
mock_os.environ.get.return_value = None
mock_restart_with_reloader.return_value = 15
reloader.watch_and_reload(mock_func, (), {})
mock_restart_with_reloader.assert_called_once_with()
mock_sys.exit.assert_called_once_with(15)
mock_os.environ.get.assert_called_once_with(
'PYSOA_RELOADER_RUN_MAIN')
self.assertFalse(mock_watch_files.called)
self.assertFalse(mock_stop_watching.called)
self.assertFalse(mock_os.getpid.called)
self.assertFalse(mock_os.kill.called)
mock_restart_with_reloader.reset_mock()
mock_sys.reset_mock()
mock_os.reset_mock()
mock_restart_with_reloader.return_value = -21
mock_os.getpid.return_value = 92738
reloader.watch_and_reload(mock_func, (), {})
mock_restart_with_reloader.assert_called_once_with()
mock_os.getpid.assert_called_once_with()
mock_os.kill.assert_called_once_with(92738, 21)
mock_os.environ.get.assert_called_once_with(
'PYSOA_RELOADER_RUN_MAIN')
self.assertFalse(mock_watch_files.called)
self.assertFalse(mock_stop_watching.called)
self.assertFalse(mock_sys.exit.called)
def test_assert_warns_regex(self):
with self.assertWarnsRegex(DeprecationWarning, '[a-z]+') as context:
warnings.warn('hello', DeprecationWarning)
assert issubclass(context.list[0].category, DeprecationWarning)
with self.assertWarnsRegex(FutureWarning, '[a-z]+') as context:
warnings.warn('goodbye', FutureWarning)
assert issubclass(context.list[0].category, FutureWarning)
with pytest.raises(pytest.raises.Exception):
with self.assertWarnsRegex(DeprecationWarning, '[a-z]+'):
warnings.warn('1234', DeprecationWarning)
flags = mock.MagicMock()
del flags.raise_value
del flags.raise_type
def raise_value(*args, **kwargs):
flags.raise_value = args, kwargs
if not args or args[0] is not False:
warnings.warn('hello', DeprecationWarning)
else:
warnings.warn('1234', DeprecationWarning)
def raise_type(*args, **kwargs):
flags.raise_type = args, kwargs
warnings.warn('goodbye', FutureWarning)
assert self.assertWarnsRegex(
DeprecationWarning, '[a-z]+', raise_value, 'foo',
bar='baz') is None
assert flags.raise_value == (('foo', ), {'bar': 'baz'})
assert self.assertWarnsRegex(
FutureWarning, '[a-z]+', raise_type, 'qux', baz='foo') is None
assert flags.raise_type == (('qux', ), {'baz': 'foo'})
with pytest.raises(pytest.raises.Exception):
self.assertWarnsRegex(DeprecationWarning, '[a-z]+', raise_value,
False)
assert flags.raise_value == ((False, ), {})
def test_cleanups(self):
flags = mock.MagicMock()
del flags.clean1
del flags.clean2
def clean1(*args, **kwargs):
flags.clean1 = args, kwargs
def clean2(*args, **kwargs):
flags.clean2 = args, kwargs
class PyTestServerTestCase1(PyTestServerTestCase):
server_class = CompleteServer
server_settings = {}
# noinspection PyDeprecation
def setup_method(self): # type: () -> None
super(PyTestServerTestCase1, self).setup_method()
self.addCleanup(clean1, 'foo', bar='baz')
self.addCleanup(clean2, 'qux', baz='foo')
case = PyTestServerTestCase1()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', DeprecationWarning)
case.setup_method()
assert w is not None
assert len(w) == 2
assert issubclass(w[0].category, DeprecationWarning)
assert issubclass(w[1].category, DeprecationWarning)
assert not hasattr(flags, 'clean1')
assert not hasattr(flags, 'clean2')
case.teardown_method()
assert flags.clean1 == (('foo', ), {'bar': 'baz'})
assert flags.clean2 == (('qux', ), {'baz': 'foo'})
def test_assert_raises_regex(self):
with self.assertRaisesRegex(ValueError, '[a-z]+') as context:
raise ValueError('hello')
assert context.value.args == ('hello', )
assert context.exception.args == ('hello', )
with self.assertRaisesRegex(TypeError, '[a-z]+') as context:
raise TypeError('goodbye')
assert context.value.args == ('goodbye', )
assert context.exception.args == ('goodbye', )
with pytest.raises(AssertionError):
with self.assertRaisesRegex(ValueError, '[a-z]+'):
raise ValueError('1234')
flags = mock.MagicMock()
del flags.raise_value
del flags.raise_type
def raise_value(*args, **kwargs):
flags.raise_value = args, kwargs
if not args or args[0] is not False:
raise ValueError('hello')
raise ValueError('1234')
def raise_type(*args, **kwargs):
flags.raise_type = args, kwargs
raise TypeError('goodbye')
assert self.assertRaisesRegex(
ValueError, '[a-z]+', raise_value, 'foo', bar='baz') is None
assert flags.raise_value == (('foo', ), {'bar': 'baz'})
assert self.assertRaisesRegex(
TypeError, '[a-z]+', raise_type, 'qux', baz='foo') is None
assert flags.raise_type == (('qux', ), {'baz': 'foo'})
with pytest.raises(AssertionError):
self.assertRaisesRegex(ValueError, '[a-z]+', raise_value, False)
assert flags.raise_value == ((False, ), {})
def test_assert_raises(self):
with self.assertRaises(ValueError) as context:
raise ValueError()
assert context.value.args == ()
assert context.exception.args == ()
with self.assertRaises(TypeError) as context:
raise TypeError()
assert context.value.args == ()
assert context.exception.args == ()
with pytest.raises(pytest.raises.Exception):
with self.assertRaises(ValueError):
assert 1 == 1
flags = mock.MagicMock()
del flags.raise_value
del flags.raise_type
def raise_value(*args, **kwargs):
flags.raise_value = args, kwargs
if not args or args[0] is not False:
raise ValueError()
def raise_type(*args, **kwargs):
flags.raise_type = args, kwargs
raise TypeError()
assert self.assertRaises(ValueError, raise_value, 'foo',
bar='baz') is None
assert flags.raise_value == (('foo', ), {'bar': 'baz'})
assert self.assertRaises(TypeError, raise_type, 'qux',
baz='foo') is None
assert flags.raise_type == (('qux', ), {'baz': 'foo'})
with pytest.raises(pytest.raises.Exception):
self.assertRaises(ValueError, raise_value, False)
assert flags.raise_value == ((False, ), {})
def test_only_file_watcher_argument_no_values(self, mock_get_reloader):
server_getter = mock.MagicMock()
sys.argv = [
'/path/to/example_service/standalone.py', '--use-file-watcher'
]
standalone.simple_main(server_getter) # type: ignore
server_getter.assert_called_once_with()
self.assertFalse(server_getter.return_value.main.called)
assert mock_get_reloader.call_count == 1
assert mock_get_reloader.call_args_list[0][0][0] in ('', 'pytest',
'coverage')
assert mock_get_reloader.call_args_list[0][0][1] is None
assert mock_get_reloader.call_args_list[0][1]['signal_forks'] is False
self.assertEqual(1, mock_get_reloader.return_value.main.call_count)
self.assertEqual(
server_getter.return_value,
mock_get_reloader.return_value.main.call_args_list[0][0][1][1],
)
def test_only_file_watcher_argument_some_values(self, mock_get_reloader):
server_getter = mock.MagicMock()
sys.argv = [
'/path/to/example_service/standalone.py', '--use-file-watcher',
'example,pysoa,conformity'
]
standalone.simple_main(server_getter)
server_getter.assert_called_once_with()
self.assertFalse(server_getter.return_value.main.called)
mock_get_reloader.assert_called_once_with(
'', ['example', 'pysoa', 'conformity'], signal_forks=False)
self.assertEqual(1, mock_get_reloader.return_value.main.call_count)
self.assertEqual(
0, mock_get_reloader.return_value.main.call_args_list[0][0][1]
[0].fork_processes)
self.assertEqual(
server_getter.return_value,
mock_get_reloader.return_value.main.call_args_list[0][0][1][1],
)
def __init__(self):
super(MockSentinelRedis, self).__init__(strict=True,
load_lua_dependencies=False)
self.connection_pool = mock.MagicMock()
self.connection_pool.get_master_address.return_value = (
'192.0.2.13', '6379') # used official "example" address
def test_filter(self):
record = mock.MagicMock()
log_filter = PySOALogContextFilter()
self.assertTrue(log_filter.filter(record))
self.assertEqual('--', record.correlation_id)
self.assertEqual('--', record.request_id)
self.assertEqual('unknown', record.service_name)
PySOALogContextFilter.set_service_name('foo_qux')
PySOALogContextFilter.set_logging_request_context(
filter='mine', **{'logger': 'yours'})
self.assertEqual({
'filter': 'mine',
'logger': 'yours'
}, PySOALogContextFilter.get_logging_request_context())
record.reset_mock()
self.assertTrue(log_filter.filter(record))
self.assertEqual('--', record.correlation_id)
self.assertEqual('--', record.request_id)
self.assertEqual('foo_qux', record.service_name)
PySOALogContextFilter.set_logging_request_context(
request_id=4321, **{'correlation_id': 'abc1234'})
self.assertEqual({
'request_id': 4321,
'correlation_id': 'abc1234'
}, PySOALogContextFilter.get_logging_request_context())
record.reset_mock()
self.assertTrue(log_filter.filter(record))
self.assertEqual('abc1234', record.correlation_id)
self.assertEqual(4321, record.request_id)
self.assertEqual('foo_qux', record.service_name)
PySOALogContextFilter.clear_logging_request_context()
self.assertEqual({
'filter': 'mine',
'logger': 'yours'
}, PySOALogContextFilter.get_logging_request_context())
record.reset_mock()
self.assertTrue(log_filter.filter(record))
self.assertEqual('--', record.correlation_id)
self.assertEqual('--', record.request_id)
self.assertEqual('foo_qux', record.service_name)
PySOALogContextFilter.clear_logging_request_context()
self.assertIsNone(PySOALogContextFilter.get_logging_request_context())
record.reset_mock()
self.assertTrue(log_filter.filter(record))
self.assertEqual('--', record.correlation_id)
self.assertEqual('--', record.request_id)
self.assertEqual('foo_qux', record.service_name)
def reset(cls, include_setup=True):
if include_setup:
if hasattr(cls, '_test_fixture_setup_called'):
del cls._test_fixture_setup_called
if hasattr(cls, '_test_fixture_setup_succeeded'):
del cls._test_fixture_setup_succeeded
cls.addError = mock.MagicMock()
cls.addFailure = mock.MagicMock()
cls.set_up_test_fixture = mock.MagicMock()
cls.tear_down_test_fixture = mock.MagicMock()
cls.setUp = mock.MagicMock()
cls.tearDown = mock.MagicMock()
cls.set_up_test_case = mock.MagicMock()
cls.tear_down_test_case = mock.MagicMock()
cls.set_up_test_case_action = mock.MagicMock()
cls.tear_down_test_case_action = mock.MagicMock()
cls._run_test_case = mock.MagicMock()
cls._all_directives = (mock.MagicMock(), )
# Mock doesn't automatically mock methods that start with `assert`, so we have to do this
cls._all_directives[
0].return_value.assert_test_fixture_results = mock.MagicMock()
def test_other_error_on_assert_test_fixture_results_some_other_errors(
self):
test_case = {'my': 'case'}
test_fixture = [{'foo': 'bar'}]
test_fixture_results = [{
'baz': None
}] # type: List[Dict[six.text_type, Optional[ActionResponse]]]
test = MockedTestCase()
case_data = mock.MagicMock()
case_data.fixture_name = 'bbb'
case_data.test_fixture = test_fixture
test_function = test._create_test_function('aaa', 'bbb', test_case,
test_fixture,
test_fixture_results)
test_function._last_fixture_test = True # type: ignore
test._pytest_first_fixture_case = case_data # type: ignore
test._pytest_last_fixture_case = case_data # type: ignore
mock_dir = cast(mock.MagicMock, test._all_directives[0])
mock_dir.return_value.assert_test_fixture_results.side_effect = Error3(
)
mock_dir.return_value.tear_down_test_fixture.side_effect = Error4()
test.setup_method()
with pytest.raises(Error3):
test_function(test)
with pytest.raises(Error4):
test.teardown_method()
test.set_up_test_fixture.assert_called_once_with(test_fixture)
test.tear_down_test_fixture.assert_not_called()
test.set_up_test_case.assert_called_once_with(test_case, test_fixture)
test.tear_down_test_case.assert_called_once_with(
test_case, test_fixture)
test.set_up_test_case_action.assert_not_called()
test.tear_down_test_case_action.assert_not_called()
test._run_test_case.assert_called_once_with(test_case, test_fixture,
test_fixture_results)
mock_dir.return_value.set_up_test_fixture.assert_called_once_with(
test_fixture)
mock_dir.return_value.assert_test_fixture_results.assert_called_once_with(
test_fixture_results,
test_fixture,
)
mock_dir.return_value.tear_down_test_fixture.assert_called_once_with(
test_fixture)
mock_dir.return_value.set_up_test_case.assert_called_once_with(
test_case, test_fixture)
mock_dir.return_value.tear_down_test_case.assert_called_once_with(
test_case, test_fixture)
mock_dir.return_value.set_up_test_case_action.assert_not_called()
mock_dir.return_value.tear_down_test_case_action.assert_not_called()
assert test.add_error.call_count == 0
assert test.setUpClass.call_count == 0
assert test.tearDownClass.call_count == 0
class MockedTestCase(ServicePlanTestCase):
server_class = _TestServiceServer
server_settings = {} # type: SettingsData
add_error = mock.MagicMock()
set_up_test_fixture = mock.MagicMock()
tear_down_test_fixture = mock.MagicMock()
set_up_test_case = mock.MagicMock()
tear_down_test_case = mock.MagicMock()
set_up_test_case_action = mock.MagicMock()
tear_down_test_case_action = mock.MagicMock()
_run_test_case = mock.MagicMock()
setUpClass = mock.MagicMock()
setUpClass.__func__ = ServicePlanTestCase.setUpClass.__func__ # type: ignore
tearDownClass = mock.MagicMock()
tearDownClass.__func__ = ServicePlanTestCase.tearDownClass.__func__ # type: ignore
_all_directives = [
cast(Type[Directive], mock.MagicMock()),
]
@classmethod
def reset(cls):
cls._test_fixture_setup_called = {} # type: ignore
cls._test_fixture_setup_succeeded = {} # type: ignore
cls.add_error = mock.MagicMock()
cls.set_up_test_fixture = mock.MagicMock()
cls.tear_down_test_fixture = mock.MagicMock()
cls.set_up_test_case = mock.MagicMock()
cls.tear_down_test_case = mock.MagicMock()
cls.set_up_test_case_action = mock.MagicMock()
cls.tear_down_test_case_action = mock.MagicMock()
cls._run_test_case = mock.MagicMock()
cls._all_directives = [
cast(Type[Directive], mock.MagicMock()),
]
# Mock doesn't automatically mock methods that start with `assert`, so we have to do this
cls._all_directives[
0].return_value.assert_test_fixture_results = mock.MagicMock(
) # type: ignore
def test_normal_fixture_tear_down(self):
test_case = {'my': 'case'}
test_fixture = [{'foo': 'bar'}]
test_fixture_results = [{
'baz': None
}] # type: List[Dict[six.text_type, Optional[ActionResponse]]]
test = MockedTestCase()
case_data = mock.MagicMock()
case_data.fixture_name = 'my_fixture'
case_data.test_fixture = test_fixture
test_function = test._create_test_function(
'My test description',
'my_fixture',
test_case,
test_fixture,
test_fixture_results,
)
test_function._last_fixture_test = True # type: ignore
test._pytest_first_fixture_case = case_data # type: ignore
test._pytest_last_fixture_case = case_data # type: ignore
assert test_function.__doc__ == 'My test description'
test.setup_method()
test_function(test)
test.teardown_method()
test.set_up_test_fixture.assert_called_once_with(test_fixture)
test.tear_down_test_fixture.assert_called_once_with(test_fixture)
test.set_up_test_case.assert_called_once_with(test_case, test_fixture)
test.tear_down_test_case.assert_called_once_with(
test_case, test_fixture)
test.set_up_test_case_action.assert_not_called()
test.tear_down_test_case_action.assert_not_called()
test._run_test_case.assert_called_once_with(test_case, test_fixture,
test_fixture_results)
mock_dir = cast(mock.MagicMock, test._all_directives[0])
mock_dir.return_value.set_up_test_fixture.assert_called_once_with(
test_fixture)
mock_dir.return_value.assert_test_fixture_results.assert_called_once_with(
test_fixture_results,
test_fixture,
)
mock_dir.return_value.tear_down_test_fixture.assert_called_once_with(
test_fixture)
mock_dir.return_value.set_up_test_case.assert_called_once_with(
test_case, test_fixture)
mock_dir.return_value.tear_down_test_case.assert_called_once_with(
test_case, test_fixture)
mock_dir.return_value.set_up_test_case_action.assert_not_called()
mock_dir.return_value.tear_down_test_case_action.assert_not_called()
test.teardown_class()
test.tear_down_test_fixture.assert_called_once_with(test_fixture)
mock_dir.return_value.tear_down_test_fixture.assert_called_once_with(
test_fixture)
test.add_error.assert_not_called()
assert test.setUpClass.call_count == 0
assert test.tearDownClass.call_count == 0
class MockedTestCase(ServicePlanTestCase):
addError = mock.MagicMock()
addFailure = mock.MagicMock()
set_up_test_fixture = mock.MagicMock()
tear_down_test_fixture = mock.MagicMock()
setUp = mock.MagicMock()
tearDown = mock.MagicMock()
set_up_test_case = mock.MagicMock()
tear_down_test_case = mock.MagicMock()
set_up_test_case_action = mock.MagicMock()
tear_down_test_case_action = mock.MagicMock()
_run_test_case = mock.MagicMock()
_all_directives = (mock.MagicMock(), )
def __init__(self):
super(MockedTestCase, self).__init__('fake_test')
def fake_test(self):
"""
This is so that we can instantiate the class.
"""
@classmethod
def reset(cls, include_setup=True):
if include_setup:
if hasattr(cls, '_test_fixture_setup_called'):
del cls._test_fixture_setup_called
if hasattr(cls, '_test_fixture_setup_succeeded'):
del cls._test_fixture_setup_succeeded
cls.addError = mock.MagicMock()
cls.addFailure = mock.MagicMock()
cls.set_up_test_fixture = mock.MagicMock()
cls.tear_down_test_fixture = mock.MagicMock()
cls.setUp = mock.MagicMock()
cls.tearDown = mock.MagicMock()
cls.set_up_test_case = mock.MagicMock()
cls.tear_down_test_case = mock.MagicMock()
cls.set_up_test_case_action = mock.MagicMock()
cls.tear_down_test_case_action = mock.MagicMock()
cls._run_test_case = mock.MagicMock()
cls._all_directives = (mock.MagicMock(), )
# Mock doesn't automatically mock methods that start with `assert`, so we have to do this
cls._all_directives[
0].return_value.assert_test_fixture_results = mock.MagicMock()
def test_forking_with_default_respawn(self, mock_cpu_count, mock_process):
server_getter = mock.MagicMock()
mock_cpu_count.return_value = 2
sys.argv = ['/path/to/example_service/standalone.py', '-f', '3']
prev_sigint = prev_sigterm = prev_sighup = None
try:
prev_sigint = signal.signal(signal.SIGINT, signal.SIG_IGN)
prev_sigterm = signal.signal(signal.SIGTERM, signal.SIG_IGN)
prev_sighup = signal.signal(signal.SIGHUP, signal.SIG_IGN)
living_processes = []
quick_dying_processes = []
slow_dying_processes = []
bad_processes = []
def patched_freeze_time():
# TODO Until https://github.com/spulec/freezegun/issues/307 is fixed
f = freezegun.freeze_time()
f.ignore = tuple(set(f.ignore) - {'threading'})
return f
with patched_freeze_time() as frozen_time:
def tick_six_se():
frozen_time.tick(datetime.timedelta(seconds=6))
def tick_twenty_se():
frozen_time.tick(datetime.timedelta(seconds=20))
def signal_se():
os.kill(os.getpid(), signal.SIGTERM)
time.sleep(0.3)
def se(target, name, args):
process = mock.MagicMock()
process.culprit = (target, name, args)
if args[0] == 1:
# If it's the first process, we want to actually live. This tests normal operation.
living_processes.append(process)
if len(living_processes) == 6:
raise ValueError('Too many, too many!')
elif len(living_processes) == 5:
process.join.side_effect = signal_se
else:
process.join.side_effect = tick_twenty_se
if len(living_processes) == 1:
time.sleep(
3
) # sleep 3 seconds so that all of these happen after quick- and slow-dying
elif args[0] == 2:
# If it's the second process, we want to die quickly. This tests the 15-second respawn limit.
quick_dying_processes.append(process)
# no sleep so that all of these happen before any ticks, before slow-dying and living
elif args[0] == 3:
# If it's the third process, we want to die slowly. This tests the 60-second respawn limit.
slow_dying_processes.append(process)
process.join.side_effect = tick_six_se
if len(slow_dying_processes) == 1:
time.sleep(
1
) # sleep 1 second so that all of these happen after quick-dying
else:
bad_processes.append((target, name, args))
raise ValueError('Nope nope nope')
return process
mock_process.side_effect = se
standalone.simple_main(server_getter) # type: ignore
server_getter.assert_called_once_with()
assert server_getter.return_value.main.called is False
assert len(bad_processes) == 0
assert len(quick_dying_processes) == 4
assert len(slow_dying_processes) == 9
assert len(living_processes) == 5
for i, p in enumerate(living_processes):
assert p.culprit[0] is server_getter.return_value.main
assert p.culprit[1] == 'pysoa-worker-1'
assert p.culprit[2] == (1, )
if i < 5:
p.start.assert_called_once_with()
p.join.assert_called_once_with()
for p in living_processes[:-1]:
assert p.terminate.called is False
living_processes[-1].terminate.assert_called_once_with()
for p in quick_dying_processes:
assert p.culprit[0] is server_getter.return_value.main
assert p.culprit[1] == 'pysoa-worker-2'
assert p.culprit[2] == (2, )
p.start.assert_called_once_with()
p.join.assert_called_once_with()
assert p.terminate.called is False
for p in slow_dying_processes:
assert p.culprit[0] is server_getter.return_value.main
assert p.culprit[1] == 'pysoa-worker-3'
assert p.culprit[2] == (3, )
p.start.assert_called_once_with()
p.join.assert_called_once_with()
assert p.terminate.called is False
finally:
if prev_sigint is not None:
signal.signal(signal.SIGINT, prev_sigint or signal.SIG_IGN)
if prev_sigterm is not None:
signal.signal(signal.SIGTERM, prev_sigterm or signal.SIG_IGN)
if prev_sighup is not None:
signal.signal(signal.SIGHUP, prev_sighup or signal.SIG_IGN)
