def testAllPhases(self):
inner_group = htf.PhaseGroup(setup=_fake_phases('a', 'b'),
main=_fake_phases('c', 'd'),
teardown=_fake_phases('e', 'f'))
outer_group = htf.PhaseGroup(setup=_fake_phases('1', '2', '3', '4'),
main=_fake_phases('5', '6') +
[inner_group] + _fake_phases('7'),
teardown=_fake_phases('8', '9'))
self.assertEqual(
_fake_phases(
'1',
'2',
'3',
'4', # Outer setup.
'5',
'6', # First outer main.
'a',
'b', # Inner setup.
'c',
'd', # Inner main.
'e',
'f', # Inner teardown.
'7', # Rest of outer main.
'8',
'9', # Outer teardown.
),
list(outer_group.all_phases())) # pyformat: disable
def testWithArgs_Recursive(self):
inner_group = htf.PhaseGroup(main=[blank_phase, arg_phase])
outer_group = htf.PhaseGroup(main=[inner_group, arg_phase])
arg_group = outer_group.with_args(arg2=2)
self.assertEqual(blank_phase, arg_group.main[0].main[0])
self.assertEqual(arg_phase.with_args(arg2=2), arg_group.main[0].main[1])
self.assertEqual(arg_phase.with_args(arg2=2), arg_group.main[1])
def testWithArgs_Recursive(self):
inner_group = htf.PhaseGroup(main=[blank_phase, arg_phase])
outer_group = htf.PhaseGroup(main=[inner_group, arg_phase])
arg_group = outer_group.with_args(arg2=2)
all_phases = list(arg_group.all_phases())
self.assertEqual(blank_phase, all_phases[0])
self.assertEqual(arg_phase.with_args(arg2=2), all_phases[1])
self.assertEqual(arg_phase.with_args(arg2=2), all_phases[2])
def testWrap_SinglePhase(self):
group = htf.PhaseGroup(setup=_fake_phases('s1'),
main=_fake_phases('m1'),
teardown=_fake_phases('t1'))
single_extra = _fake_phases('m2', 'm3')[0]
expected = htf.PhaseGroup(setup=_fake_phases('s1'),
main=_fake_phases('m1', 'm2'),
teardown=_fake_phases('t1'))
self.assertEqual(expected, group.wrap(single_extra))
def testApplyToAllPhases_Full(self):
group = htf.PhaseGroup(setup=_fake_phases('setup'),
main=_fake_phases('main'),
teardown=_fake_phases('teardown'),
name='group')
expected = htf.PhaseGroup(setup=_fake_phases('prefix:setup'),
main=_fake_phases('prefix:main'),
teardown=_fake_phases('prefix:teardown'),
name='group')
self.assertEqual(expected, group.apply_to_all_phases(_prefix_name))
def testWithPlugs_Recursive(self):
inner_group = htf.PhaseGroup(main=[blank_phase, plug_phase])
outer_group = htf.PhaseGroup(main=[inner_group, plug_phase])
plug_group = outer_group.with_plugs(my_plug=ChildPlug)
self.assertEqual(blank_phase, plug_group.main[0].main[0])
self.assertEqual(plug_phase.with_plugs(my_plug=ChildPlug),
plug_group.main[0].main[1])
self.assertEqual(plug_phase.with_plugs(my_plug=ChildPlug),
plug_group.main[1])
def testWithPlugs_Recursive(self):
inner_group = htf.PhaseGroup(main=[blank_phase, plug_phase])
outer_group = htf.PhaseGroup(main=[inner_group, plug_phase])
plug_group = outer_group.with_plugs(my_plug=ChildPlug)
all_phases = list(plug_group.all_phases())
self.assertEqual(blank_phase, all_phases[0])
self.assertEqual(plug_phase.with_plugs(my_plug=ChildPlug),
all_phases[1])
self.assertEqual(plug_phase.with_plugs(my_plug=ChildPlug),
all_phases[2])
def testCombine(self):
group1 = htf.PhaseGroup(setup=_fake_phases('s1'),
main=_fake_phases('m1'),
teardown=_fake_phases('t1'))
group2 = htf.PhaseGroup(setup=_fake_phases('s2'),
main=_fake_phases('m2'),
teardown=_fake_phases('t2'))
expected = htf.PhaseGroup(setup=_fake_phases('s1', 's2'),
main=_fake_phases('m1', 'm2'),
teardown=_fake_phases('t1', 't2'))
self.assertEqual(expected, group1.combine(group2))
def testAsDict_Full(self, mock_phase_asdict):
def phase_asdict(self_phase):
return self_phase.name
mock_phase_asdict.side_effect = phase_asdict
setup = _fake_phases('setup')
main = _fake_phases('main')
teardown = _fake_phases('teardown')
group = htf.PhaseGroup(setup=setup,
main=main,
teardown=teardown,
name='group')
self.assertEqual(
{
'setup': {
'nodes': ['setup'],
'name': None
},
'main': {
'nodes': ['main'],
'name': None
},
'teardown': {
'nodes': ['teardown'],
'name': None
},
'name': 'group',
}, group._asdict())
mock_phase_asdict.assert_has_calls(
[mock.call(setup[0]),
mock.call(main[0]),
mock.call(teardown[0])])
def testRecursive(self):
inner = htf.PhaseGroup(setup=_fake_phases('inner-setup'),
main=_fake_phases('inner-main'),
teardown=_fake_phases('inner-teardown'),
name='inner')
recursive = htf.PhaseGroup(setup=_fake_phases('setup'),
main=(_fake_phases('main-pre') + [inner] +
_fake_phases('main-post')),
teardown=_fake_phases('teardown'),
name='recursive')
test_rec = yield htf.Test(recursive)
self.assertTestPass(test_rec)
self._assert_phase_names([
'setup', 'main-pre', 'inner-setup', 'inner-main', 'inner-teardown',
'main-post', 'teardown'
], test_rec)
def testRecursive_FailureSetup(self):
inner_fail = htf.PhaseGroup(
setup=(_fake_phases('inner-setup0') + [stop_phase] +
_fake_phases('not-run')),
main=_fake_phases('not-run-inner'),
teardown=_fake_phases('not-run-inner-teardown'),
name='inner_fail')
outer = htf.PhaseGroup(setup=_fake_phases('setup0'),
main=_fake_phases('outer0') + [inner_fail] +
_fake_phases('not-run'),
teardown=_fake_phases('teardown0'),
name='outer')
test_rec = yield htf.Test(outer)
self.assertTestFail(test_rec)
self._assert_phase_names(
['setup0', 'outer0', 'inner-setup0', 'stop_phase', 'teardown0'],
test_rec)
def testFailure_Before(self):
not_run = htf.PhaseGroup(setup=_fake_phases('not-run-setup'),
main=_fake_phases('not-run-main'),
teardown=_fake_phases('not-run-teardown'),
name='not_run')
test_rec = yield htf.Test(stop_phase, not_run)
self.assertTestFail(test_rec)
self._assert_phase_names(['stop_phase'], test_rec)
def testWithTeardown(self):
main = _fake_phases('main')
teardown = _fake_phases('teardown')
expected = htf.PhaseGroup(main=main, teardown=teardown)
wrapper = htf.PhaseGroup.with_teardown(*teardown)
group = wrapper(*main)
self.assertEqual(expected, group)
def testWithSetup(self):
setup = _fake_phases('setup')
main = _fake_phases('main')
expected = htf.PhaseGroup(setup=setup, main=main)
wrapper = htf.PhaseGroup.with_setup(*setup)
group = wrapper(*main)
self.assertEqual(expected, group)
def testFailure_Setup(self):
fail_setup = htf.PhaseGroup(setup=[stop_phase] +
_fake_phases('not-run-setup'),
main=_fake_phases('not-run-main'),
teardown=_fake_phases('not-run-teardown'),
name='fail_setup')
test_rec = yield htf.Test(fail_setup)
self.assertTestFail(test_rec)
self._assert_phase_names(['stop_phase'], test_rec)
def testWithContext(self):
setup = _fake_phases('setup')
main = _fake_phases('main')
teardown = _fake_phases('teardown')
expected = htf.PhaseGroup(setup=setup, main=main, teardown=teardown)
wrapper = htf.PhaseGroup.with_context(setup, teardown)
group = wrapper(*main)
self.assertEqual(expected, group)
def testAsDict_Empty(self, mock_phase_asdict):
group = htf.PhaseGroup(name='group')
self.assertEqual(
{
'setup': None,
'main': None,
'teardown': None,
'name': 'group',
}, group._asdict())
mock_phase_asdict.assert_not_called()
def testFailure_Teardown(self):
fail_teardown = htf.PhaseGroup(setup=_fake_phases('setup'),
main=_fake_phases('main'),
teardown=_fake_phases('td0') +
[stop_phase] + _fake_phases('td1'),
name='fail_teardown')
test_rec = yield htf.Test(fail_teardown)
self.assertTestFail(test_rec)
self._assert_phase_names(['setup', 'main', 'td0', 'stop_phase', 'td1'],
test_rec)
def testInit(self): setup = [1] main = [2] teardown = [3] name = 'name' pg = htf.PhaseGroup(setup=setup, main=main, teardown=teardown, name=name) self.assertEqual(tuple(setup), pg.setup) self.assertEqual(tuple(main), pg.main) self.assertEqual(tuple(teardown), pg.teardown) self.assertEqual(name, pg.name)
def testLoadCodeInfo(self):
group = htf.PhaseGroup(
setup=_fake_phases('setup'),
main=_fake_phases('main'),
teardown=_fake_phases('teardown'))
code_group = group.load_code_info()
self.assertEqual(blank.__name__, code_group.setup[0].code_info.name)
self.assertEqual(blank.__name__, code_group.main[0].code_info.name)
self.assertEqual(
blank.__name__, code_group.teardown[0].code_info.name)
def testLoadCodeInfo(self):
group = htf.PhaseGroup(setup=_fake_phases('setup'),
main=_fake_phases('main'),
teardown=_fake_phases('teardown'))
code_group = group.load_code_info()
all_phases = list(code_group.all_phases())
code_info = test_record.CodeInfo.for_function(blank)
self.assertEqual(code_info, all_phases[0].code_info)
self.assertEqual(code_info, all_phases[1].code_info)
self.assertEqual(code_info, all_phases[2].code_info)
def testSimple(self):
simple = htf.PhaseGroup(setup=_fake_phases('setup0', 'setup1'),
main=_fake_phases('main0', 'main1'),
teardown=_fake_phases('teardown0',
'teardown1'),
name='simple')
test_rec = yield htf.Test(simple)
self.assertTestPass(test_rec)
self._assert_phase_names(
['setup0', 'setup1', 'main0', 'main1', 'teardown0', 'teardown1'],
test_rec)
def run_basic_group():
"""Run the basic phase group example.
In this example, there are no terminal phases; all phases are run.
"""
test = htf.Test(
htf.PhaseGroup(
setup=[setup_phase],
main=[main_phase],
teardown=[teardown_phase],
))
test.execute()
def testFlatten(self):
inner = htf.PhaseGroup(
setup=_fake_phases('a', 'b') + [_fake_phases('c')],
main=[_fake_phases('d')],
teardown=[_fake_phases('e'), _fake_phases('f')] + _fake_phases('g'))
outer = htf.PhaseGroup(
setup=_fake_phases('1', '2'),
main=[_fake_phases('3')] + [inner, _fake_phases('4')] +
_fake_phases('5'),
teardown=_fake_phases('6') + [_fake_phases('7', '8')] +
_fake_phases('9'))
expected_inner = htf.PhaseGroup(
setup=_fake_phases('a', 'b', 'c'),
main=_fake_phases('d'),
teardown=_fake_phases('e', 'f', 'g'))
expected_outer = htf.PhaseGroup(
setup=_fake_phases('1', '2'),
main=_fake_phases('3') + [expected_inner] + _fake_phases('4', '5'),
teardown=_fake_phases('6', '7', '8', '9'))
self.assertEqual(expected_outer, outer.flatten())
def run_main_error_group():
"""Run the phase group example where an error occurs in a main phase.
The main phase in this example is terminal. The PhaseGroup was entered
because the setup phases ran without error, so the teardown phases are run.
The other main phase is skipped.
"""
test = htf.Test(
htf.PhaseGroup(
setup=[setup_phase],
main=[error_main_phase, main_phase],
teardown=[teardown_phase],
))
test.execute()
def run_setup_error_group():
"""Run the phase group example where an error occurs in a setup phase.
The terminal setup phase shortcuts the test. The main phases are
skipped. The PhaseGroup is not entered, so the teardown phases are also
skipped.
"""
test = htf.Test(
htf.PhaseGroup(
setup=[error_setup_phase],
main=[main_phase],
teardown=[teardown_phase],
))
test.execute()
def test_fail__with_nested_group_fail_in_setup(self):
subtest = phase_collections.Subtest(
'it_fails',
htf.PhaseGroup(
setup=[fail_subtest_phase],
main=[skip_phase0],
teardown=[skip_phase1]), skip_phase)
test_rec = yield htf.Test(subtest, phase)
self.assertTestFail(test_rec)
fail_phase_rec = test_rec.phases[1]
self.assertEqual('fail_subtest_phase', fail_phase_rec.name)
self.assertPhaseOutcomeFail(fail_phase_rec)
self.assertPhaseFailSubtest(fail_phase_rec)
self.assertEqual('it_fails', fail_phase_rec.subtest_name)
skip_phase0_rec = test_rec.phases[2]
self.assertEqual('skip_phase0', skip_phase0_rec.name)
self.assertPhaseSkip(skip_phase0_rec)
self.assertPhaseOutcomeSkip(skip_phase0_rec)
self.assertEqual('it_fails', skip_phase0_rec.subtest_name)
skip_phase1_rec = test_rec.phases[3]
self.assertEqual('skip_phase1', skip_phase1_rec.name)
self.assertPhaseSkip(skip_phase1_rec)
self.assertPhaseOutcomeSkip(skip_phase1_rec)
self.assertEqual('it_fails', skip_phase1_rec.subtest_name)
skip_phase_rec = test_rec.phases[4]
self.assertEqual('skip_phase', skip_phase_rec.name)
self.assertPhaseSkip(skip_phase_rec)
self.assertPhaseOutcomeSkip(skip_phase_rec)
self.assertEqual('it_fails', skip_phase_rec.subtest_name)
continue_phase_rec = test_rec.phases[5]
self.assertEqual('phase', continue_phase_rec.name)
self.assertPhaseOutcomePass(continue_phase_rec)
self.assertPhaseContinue(continue_phase_rec)
self.assertIsNone((continue_phase_rec.subtest_name))
self.assertEqual([
test_record.SubtestRecord(
name='it_fails',
start_time_millis=htf_test.VALID_TIMESTAMP,
end_time_millis=htf_test.VALID_TIMESTAMP,
outcome=test_record.SubtestOutcome.FAIL),
], test_rec.subtests)
def testAbort_Teardown(self):
@htf.PhaseOptions()
def abort_phase():
_abort_test_in_thread(test)
abort_teardown = htf.PhaseGroup(setup=_fake_phases('setup0'),
main=_fake_phases('main0'),
teardown=_fake_phases('td0') +
[abort_phase] + _fake_phases('td1'),
name='abort_teardown')
test = htf.Test(abort_teardown)
test_rec = yield test
self.assertTestAborted(test_rec)
self._assert_phase_names(
['setup0', 'main0', 'td0', 'abort_phase', 'td1'], test_rec)
def testAbort_Setup(self):
@htf.PhaseOptions()
def abort_phase():
_abort_test_in_thread(test)
abort_setup = htf.PhaseGroup(setup=_fake_phases('setup0') +
[abort_phase] + _fake_phases('not-run'),
main=_fake_phases('not-run-main'),
teardown=_fake_phases('not-run-teardown'),
name='abort_setup')
test = htf.Test(abort_setup)
test_rec = yield test
self.assertTestAborted(test_rec)
self._assert_phase_names(['setup0', 'abort_phase'], test_rec)
def testConstruct(self):
setup = _fake_phases('1')
main = _fake_phases('2')
teardown = _fake_phases('3')
name = 'name'
pg = htf.PhaseGroup(setup=setup,
main=main,
teardown=teardown,
name=name)
self.assertEqual(phase_collections.PhaseSequence(tuple(setup)),
pg.setup)
self.assertEqual(phase_collections.PhaseSequence(tuple(main)), pg.main)
self.assertEqual(phase_collections.PhaseSequence(tuple(teardown)),
pg.teardown)
self.assertEqual(name, pg.name)
