def setUp(self):
super(TestExecutorExecuteBranchTest, self).setUp()
self.diag_store = diagnoses_lib.DiagnosesStore()
self.mock_test_record = mock.create_autospec(test_record.TestRecord)
self.mock_logger = mock.create_autospec(logging.Logger)
self.test_state = mock.MagicMock(
spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
diagnoses_manager=mock.MagicMock(
spec=diagnoses_lib.DiagnosesManager, store=self.diag_store),
execution_uid='01234567890',
test_record=self.mock_test_record,
state_logger=self.mock_logger)
td = test_descriptor.TestDescriptor(
phase_sequence=phase_collections.PhaseSequence(
phase_group.PhaseGroup()),
code_info=test_record.CodeInfo.uncaptured(),
metadata={})
self.test_exec = test_executor.TestExecutor(
td,
td.uid,
None,
test_descriptor.TestOptions(),
run_with_profiling=False)
self.test_exec.test_state = self.test_state
patcher = mock.patch.object(self.test_exec, '_execute_sequence')
self.mock_execute_sequence = patcher.start()
def _handle_phase(self, phase_desc):
"""Handle execution of a single test phase."""
logs.configure_logging()
self._initialize_plugs(phase_plug.cls
for phase_plug in phase_desc.plugs)
# Cobble together a fake TestState to pass to the test phase.
test_options = test_descriptor.TestOptions()
with mock.patch('openhtf.plugs.PlugManager',
new=lambda _, __: self.plug_manager):
test_state_ = test_state.TestState(
openhtf.TestDescriptor((phase_desc, ), phase_desc.code_info,
{}), 'Unittest:StubTest:UID',
test_options)
test_state_.mark_test_started()
# Actually execute the phase, saving the result in our return value.
executor = phase_executor.PhaseExecutor(test_state_)
# Log an exception stack when a Phase errors out.
with mock.patch.object(phase_executor.PhaseExecutorThread,
'_log_exception',
side_effect=logging.exception):
# Use _execute_phase_once because we want to expose all possible outcomes.
executor._execute_phase_once(phase_desc,
is_last_repeat=False,
run_with_profiling=False)
return test_state_.test_record.phases[-1]
def setUp(self):
super(TestExecutorHandlePhaseTest, self).setUp()
self.test_state = mock.MagicMock(
spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
execution_uid='01234567890',
state_logger=mock.MagicMock(),
test_options=test_descriptor.TestOptions(),
test_record=mock.MagicMock())
self.phase_exec = mock.MagicMock(spec=phase_executor.PhaseExecutor)
self.test_exec = test_executor.TestExecutor(
None, 'uid', None, test_descriptor.TestOptions())
self.test_exec.test_state = self.test_state
self.test_exec._phase_exec = self.phase_exec
patcher = mock.patch.object(self.test_exec, '_execute_phase_group')
self.mock_execute_phase_group = patcher.start()
def setUp(self):
mock_test_descriptor = mock.MagicMock()
self.test_state = test_state.TestState(mock_test_descriptor, 'testing-123',
test_descriptor.TestOptions())
self.running_phase_state = test_state.PhaseState.from_descriptor(
test_phase, lambda *args: None)
self.test_state.running_phase_state = self.running_phase_state
self.test_api = self.test_state.test_api
def setUp(self):
super(TestPhaseDescriptor, self).setUp()
self._test_state = test_state.TestState(
test_descriptor.TestDescriptor(
phase_sequence=phase_collections.PhaseSequence(),
code_info=test_record.CodeInfo.uncaptured(),
metadata={}),
execution_uid='',
test_options=test_descriptor.TestOptions())
def setUp(self):
self.test_descriptor = test_descriptor.TestDescriptor(
phase_group.PhaseGroup(main=[test_phase]), None, {'config': {}})
self.test_state = test_state.TestState(self.test_descriptor, 'testing-123',
test_descriptor.TestOptions())
self.test_record = self.test_state.test_record
self.running_phase_state = test_state.PhaseState.from_descriptor(
test_phase, lambda *args: None)
self.test_state.running_phase_state = self.running_phase_state
self.test_api = self.test_state.test_api
def setUp(self):
super(TestExecutorExecutePhasesTest, self).setUp()
self.test_state = mock.MagicMock(spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
execution_uid='01234567890',
state_logger=mock.MagicMock())
self.test_exec = test_executor.TestExecutor(
None, 'uid', None, test_descriptor.TestOptions())
self.test_exec.test_state = self.test_state
patcher = mock.patch.object(self.test_exec, '_handle_phase')
self.mock_handle_phase = patcher.start()
def setUp(self):
self.test_state = mock.MagicMock(
spec=test_state.TestState,
plug_manager=plugs.PlugManager(
record_logger_name='mock.logger.for.openhtf'),
execution_uid='01234567890',
logger=mock.MagicMock())
self.test_exec = test_executor.TestExecutor(
None, 'uid', None, test_descriptor.TestOptions())
self.test_exec.test_state = self.test_state
patcher = mock.patch.object(self.test_exec, '_handle_phase')
self.mock_handle_phase = patcher.start()
def _handle_phase(self, phase_desc):
"""Handle execution of a single test phase."""
phase_descriptor.check_for_duplicate_results(iter([phase_desc]), [])
logs.configure_logging()
self._initialize_plugs(phase_plug.cls
for phase_plug in phase_desc.plugs)
# Cobble together a fake TestState to pass to the test phase.
test_options = test_descriptor.TestOptions()
with mock.patch.object(plugs,
'PlugManager',
new=lambda _, __: self.plug_manager):
test_state_ = test_state.TestState(
test_descriptor.TestDescriptor(
phase_collections.PhaseSequence((phase_desc, )),
phase_desc.code_info, {}), 'Unittest:StubTest:UID',
test_options)
test_state_.mark_test_started()
test_state_.user_defined_state.update(self.phase_user_defined_state)
for diag in self.phase_diagnoses:
test_state_.diagnoses_manager._add_diagnosis(diag) # pylint: disable=protected-access
test_state_.test_record.add_diagnosis(diag)
# Save the test_state to the last_test_case attribute to give it access to
# the underlying state.
self.test_case.last_test_state = test_state_
# Actually execute the phase, saving the result in our return value.
executor = phase_executor.PhaseExecutor(test_state_)
profile_filepath = self.test_case.get_profile_filepath()
# Log an exception stack when a Phase errors out.
with mock.patch.object(phase_executor.PhaseExecutorThread,
'_log_exception',
side_effect=logging.exception):
# Use _execute_phase_once because we want to expose all possible outcomes.
phase_result, profile_stats = executor._execute_phase_once(
phase_desc,
is_last_repeat=False,
run_with_profiling=profile_filepath,
subtest_rec=None)
if profile_filepath is not None:
_merge_stats(profile_stats, profile_filepath)
if phase_result.raised_exception:
failure_message = phase_result.phase_result.get_traceback_string()
else:
failure_message = None
return test_state_.test_record.phases[-1], failure_message
def setUp(self):
super(TestExecutorExecutePhaseTest, self).setUp()
self.test_state = mock.MagicMock(
spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
execution_uid='01234567890',
state_logger=mock.MagicMock(),
test_options=test_descriptor.TestOptions(),
test_record=mock.MagicMock())
self.phase_exec = mock.MagicMock(spec=phase_executor.PhaseExecutor)
td = test_descriptor.TestDescriptor(
phase_sequence=phase_collections.PhaseSequence(
phase_group.PhaseGroup()),
code_info=test_record.CodeInfo.uncaptured(),
metadata={})
self.test_exec = test_executor.TestExecutor(
td,
td.uid,
None,
test_descriptor.TestOptions(),
run_with_profiling=False)
self.test_exec.test_state = self.test_state
self.test_exec._phase_exec = self.phase_exec
def setUp(self):
super(TestTestApi, self).setUp()
patcher = mock.patch.object(test_record.PhaseRecord, 'record_start_time',
return_value=11235)
self.mock_record_start_time = patcher.start()
self.addCleanup(patcher.stop)
self.test_descriptor = test_descriptor.TestDescriptor(
phase_group.PhaseGroup(main=[test_phase]), None, {'config': {}})
self.test_state = test_state.TestState(self.test_descriptor, 'testing-123',
test_descriptor.TestOptions())
self.test_record = self.test_state.test_record
self.running_phase_state = test_state.PhaseState.from_descriptor(
test_phase, self.test_state, logging.getLogger())
self.test_state.running_phase_state = self.running_phase_state
self.test_api = self.test_state.test_api
def setUp(self):
super(TestTestApi, self).setUp()
patcher = mock.patch.object(
test_record.PhaseRecord, 'record_start_time', return_value=11235)
self.mock_record_start_time = patcher.start()
self.addCleanup(patcher.stop)
self.test_descriptor = test_descriptor.TestDescriptor(
phase_collections.PhaseSequence((test_phase,)),
test_record.CodeInfo.uncaptured(), {'config': {}})
self.test_state = test_state.TestState(self.test_descriptor, 'testing-123',
test_descriptor.TestOptions())
self.test_record = self.test_state.test_record
self.running_phase_state = test_state.PhaseState.from_descriptor(
test_phase, self.test_state, logging.getLogger())
self.test_state.running_phase_state = self.running_phase_state
self.test_api = self.test_state.test_api
def setUp(self):
super(TestExecutorExecutePhaseGroupTest, self).setUp()
self.test_state = mock.MagicMock(spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
execution_uid='01234567890',
state_logger=mock.MagicMock())
td = test_descriptor.TestDescriptor(
phase_sequence=phase_collections.PhaseSequence(
phase_group.PhaseGroup()),
code_info=test_record.CodeInfo.uncaptured(),
metadata={})
self.test_exec = test_executor.TestExecutor(
td,
td.uid,
None,
test_descriptor.TestOptions(),
run_with_profiling=False)
self.test_exec.test_state = self.test_state
patcher = mock.patch.object(self.test_exec, '_execute_sequence')
self.mock_execute_sequence = patcher.start()
@phase_descriptor.PhaseOptions()
def setup():
pass
self._setup = phase_collections.PhaseSequence((setup, ))
@phase_descriptor.PhaseOptions()
def main():
pass
self._main = phase_collections.PhaseSequence((main, ))
@openhtf.PhaseOptions(timeout_s=30)
def teardown():
pass
self._teardown = phase_collections.PhaseSequence((teardown, ))
self.group = phase_group.PhaseGroup(setup=self._setup,
main=self._main,
teardown=self._teardown,
name='group')
def _handle_phase(self, phase_desc):
"""Handle execution of a single test phase."""
self._initialize_plugs(phase_plug.cls
for phase_plug in phase_desc.plugs)
# Cobble together a fake TestState to pass to the test phase.
test_options = test_descriptor.TestOptions()
with mock.patch('openhtf.plugs.PlugManager',
new=lambda _, __: self.plug_manager):
test_state_ = test_state.TestState(
openhtf.TestDescriptor((phase_desc, ), phase_desc.code_info,
{}), 'Unittest:StubTest:UID',
test_options)
test_state_.mark_test_started()
# Actually execute the phase, saving the result in our return value.
executor = phase_executor.PhaseExecutor(test_state_)
# Use _execute_phase_once because we want to expose all possible outcomes.
executor._execute_phase_once(phase_desc, is_last_repeat=False)
return test_state_.test_record.phases[-1]
def setUp(self):
super(TestExecutorExecutePhaseGroupTest, self).setUp()
self.test_state = mock.MagicMock(spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
execution_uid='01234567890',
state_logger=mock.MagicMock())
self.test_exec = test_executor.TestExecutor(
None,
'uid',
None,
test_descriptor.TestOptions(),
run_with_profiling=False)
self.test_exec.test_state = self.test_state
patcher = mock.patch.object(self.test_exec,
'_execute_abortable_phases')
self.mock_execute_abortable = patcher.start()
patcher = mock.patch.object(self.test_exec, '_execute_teardown_phases')
self.mock_execute_teardown = patcher.start()
def setup():
pass
self._setup = setup
def main():
pass
self._main = main
@openhtf.PhaseOptions(timeout_s=30)
def teardown():
pass
self._teardown = teardown
self.group = phase_group.PhaseGroup(setup=[setup],
main=[main],
teardown=[teardown],
name='group')
