def setUp(self):
self.test_state = mock.MagicMock(spec=TestState,
plug_manager=plugs.PlugManager(),
logger=mock.MagicMock())
self.test_state.plug_manager.initialize_plugs([
UnittestPlug, MoreRepeatsUnittestPlug])
self.phase_executor = PhaseExecutor(self.test_state)
def __init__(self, test_desc: 'test_descriptor.TestDescriptor',
execution_uid: Text,
test_options: 'test_descriptor.TestOptions'):
"""Initializer.
Args:
test_desc: openhtf.TestDescriptor instance describing the test to run,
used to initialize some values here, but it is not modified.
execution_uid: a unique uuid use to identify a test being run.
test_options: test_options passed through from Test.
"""
super(TestState, self).__init__()
self._status = self.Status.WAITING_FOR_TEST_START # type: TestState.Status
self.test_record = test_record.TestRecord(
dut_id=None,
station_id=conf.station_id,
code_info=test_desc.code_info,
start_time_millis=0,
# Copy metadata so we don't modify test_desc.
metadata=copy.deepcopy(test_desc.metadata),
diagnosers=test_options.diagnosers)
logs.initialize_record_handler(execution_uid, self.test_record,
self.notify_update)
self.state_logger = logs.get_record_logger_for(execution_uid)
self.plug_manager = plugs.PlugManager(test_desc.plug_types,
self.state_logger)
self.diagnoses_manager = diagnoses_lib.DiagnosesManager(
self.state_logger.getChild('diagnoses'))
self.running_phase_state = None # type: Optional['PhaseState']
self._running_test_api = None # type: Optional['test_descriptor.TestApi']
# TODO(arsharma): Change to Dict[Any, Any] when pytype handles it correctly.
self.user_defined_state = {} # type: Any
self.execution_uid = execution_uid
self.test_options = test_options
def __init__(self, iterator, mock_plugs):
"""Create an iterator for iterating over Tests or phases to run.
Args:
iterator: Child iterator to use for obtaining Tests or test phases, must
be a generator.
mock_plugs: Dict mapping plug types to mock objects to use instead of
actually instantiating that type.
Raises:
InvalidTestError: when iterator is not a generator.
"""
if not isinstance(iterator, types.GeneratorType):
raise InvalidTestError(
'Methods decorated with patch_plugs or yields_phases must yield '
'test phases or openhtf.Test objects.', iterator)
# Since we want to run single phases, we instantiate our own PlugManager.
# Don't do this sort of thing outside OpenHTF unless you really know what
# you're doing (http://imgur.com/iwBCmQe).
self.plug_manager = plugs.PlugManager(
record_logger_name='test.PlugManager')
self.iterator = iterator
self.mock_plugs = mock_plugs
self.last_result = None
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 setUp(self):
self.test_state = mock.MagicMock(
spec=test_state.TestState,
plug_manager=plugs.PlugManager(logger_name='mock.logger.for.openhtf'),
execution_uid='01234567890')
self.test_state.plug_manager.initialize_plugs([
UnittestPlug, MoreRepeatsUnittestPlug])
self.phase_executor = phase_executor.PhaseExecutor(self.test_state)
def setUp(self):
super(PhaseExecutorTest, self).setUp()
self.test_state = mock.MagicMock(spec=test_state.TestState,
plug_manager=plugs.PlugManager(),
execution_uid='01234567890',
state_logger=mock.MagicMock())
self.test_state.plug_manager.initialize_plugs(
[UnittestPlug, MoreRepeatsUnittestPlug])
self.phase_executor = phase_executor.PhaseExecutor(self.test_state)
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 __init__(self, test_desc, execution_uid):
super(TestState, self).__init__()
self._status = self.Status.WAITING_FOR_TEST_START
self.test_record = test_record.TestRecord(
dut_id=None, station_id=conf.station_id, code_info=test_desc.code_info,
# Copy metadata so we don't modify test_desc.
metadata=copy.deepcopy(test_desc.metadata))
self.logger = logs.initialize_record_logger(
execution_uid, self.test_record, self.notify_update)
self.plug_manager = plugs.PlugManager(test_desc.plug_types, self.logger)
self.running_phase_state = None
self.user_defined_state = {}
self.execution_uid = execution_uid
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):
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 Execute(self, test_start=None, loop=None):
"""Starts the framework and executes the given test.
Args:
test_start: Trigger for starting the test, defaults to not setting the DUT
serial number.
loop: DEPRECATED
"""
# TODO(madsci): Remove this after a transitionary period.
if loop is not None:
raise ValueError(
'DEPRECATED. Looping is no longer natively supported by OpenHTF, '
'use a while True: loop around Test.Execute() instead.')
# We have to lock this section to ensure we don't call
# TestExecutor.StopFromSigInt() in self.Stop() between instantiating it and
# .Start()'ing it.
with self._lock:
self._executor = exe.TestExecutor(
self._test_data, plugs.PlugManager(),
self._test_options.teardown_function)
_LOG.info('Executing test: %s', self.data.code_info.name)
self._executor.SetTestStart(test_start)
http_server = None
if self._test_options.http_port:
http_server = http_api.Server(self._executor,
self._test_options.http_port)
http_server.Start()
self._executor.Start()
try:
self._executor.Wait()
finally:
# If the framework doesn't transition from INITIALIZING to EXECUTING
# then test state isn't set and there's no record to output.
if self._executor and self._executor.GetState():
record = self._executor.GetState().GetFinishedRecord()
self.OutputTestRecord(record)
if http_server:
http_server.Stop()
self._executor = None
def setUp(self):
super(TestExecutorExecuteSequencesTest, 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_node')
self.mock_execute_node = patcher.start()
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')
def __init__(self, test_case, iterator, mock_plugs,
phase_user_defined_state, phase_diagnoses):
"""Create an iterator for iterating over Tests or phases to run.
This should only be instantiated internally.
Args:
test_case: TestCase subclass where the test case function is defined.
iterator: Child iterator to use for obtaining Tests or test phases, must
be a generator.
mock_plugs: Dict mapping plug types to mock objects to use instead of
actually instantiating that type.
phase_user_defined_state: If not None, a dictionary that will be added to
the test_state.user_defined_state when handling phases.
phase_diagnoses: If not None, must be a list of Diagnosis instances; these
are added to the DiagnosesManager when handling phases.
Raises:
InvalidTestError: when iterator is not a generator.
"""
if not isinstance(iterator, types.GeneratorType):
raise InvalidTestError(
'Methods decorated with patch_plugs or yields_phases must yield '
'test phases or openhtf.Test objects.', iterator)
# Since we want to run single phases, we instantiate our own PlugManager.
# Don't do this sort of thing outside OpenHTF unless you really know what
# you're doing (http://imgur.com/iwBCmQe).
self.plug_manager = plugs.PlugManager()
self.test_case = test_case
self.iterator = iterator
self.mock_plugs = mock_plugs
self.last_result = None
if not phase_user_defined_state:
phase_user_defined_state = {}
self.phase_user_defined_state = phase_user_defined_state
if not phase_diagnoses:
phase_diagnoses = []
self.phase_diagnoses = phase_diagnoses
def __init__(self, test_desc, execution_uid, test_options):
super(TestState, self).__init__()
self._status = self.Status.WAITING_FOR_TEST_START
self.test_record = test_record.TestRecord(
dut_id=None,
station_id=conf.station_id,
code_info=test_desc.code_info,
start_time_millis=0,
# Copy metadata so we don't modify test_desc.
metadata=copy.deepcopy(test_desc.metadata),
diagnosers=test_options.diagnosers)
logs.initialize_record_handler(execution_uid, self.test_record,
self.notify_update)
self.state_logger = logs.get_record_logger_for(execution_uid)
self.plug_manager = plugs.PlugManager(test_desc.plug_types,
self.state_logger)
self.diagnoses_manager = diagnoses_lib.DiagnosesManager(
self.state_logger.getChild('diagnoses'))
self.running_phase_state = None
self._running_test_api = None
self.user_defined_state = {}
self.execution_uid = execution_uid
self.test_options = test_options
def setUp(self):
self.plug_manager = plugs.PlugManager(
{AdderPlug}, record_logger_name='mock.logger.for.openhtf')
AdderPlug.INSTANCE_COUNT = 0
def setUp(self):
super(TestPhaseDescriptor, self).setUp()
self._phase_data = mock.Mock(
plug_manager=plugs.PlugManager(),
execution_uid='01234567890')
def setUp(self):
self.plug_manager = plugs.PlugManager({AdderPlug})
AdderPlug.INSTANCE_COUNT = 0
def setUp(self):
self._phase_data = mock.Mock(plug_manager=plugs.PlugManager(
record_logger_name='mock.logger.for.openhtf'),
execution_uid='01234567890')
def setUp(self):
super(PlugsTest, self).setUp()
self.plug_manager = plugs.PlugManager({AdderPlug})
AdderPlug.INSTANCE_COUNT = 0
def setUp(self):
self._phase_data = mock.Mock(plug_manager=plugs.PlugManager())
def setUp(self):
self.logger = mock.MagicMock()
self.plug_manager = plugs.PlugManager({AdderPlug}, self.logger)
AdderPlug.INSTANCE_COUNT = 0
