def test_phase_multiple_diagnoses_with_failure(self):
@htf.PhaseDiagnoser(OkayResult)
def fine_diag(phase_record):
del phase_record # Unused.
return htf.Diagnosis(OkayResult.FINE, 'Fine'),
@htf.PhaseDiagnoser(BadResult)
def bad_diag(phase_record):
del phase_record # Unused.
return htf.Diagnosis(BadResult.ONE, 'Bad!', is_failure=True)
phase = htf.diagnose(fine_diag, bad_diag)(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomeFail(phase_rec)
self.assertEqual([OkayResult.FINE], phase_rec.diagnosis_results)
self.assertEqual([BadResult.ONE], phase_rec.failure_diagnosis_results)
store = self.get_diagnoses_store()
self.assertEqual(
htf.Diagnosis(OkayResult.FINE, 'Fine'),
store.get_diagnosis(OkayResult.FINE))
self.assertEqual(
htf.Diagnosis(BadResult.ONE, 'Bad!', is_failure=True),
store.get_diagnosis(BadResult.ONE))
def test_failed_phase_diagnoser_on_test(self):
phase = htf.diagnose(fail_phase_diagnoser)(basic_phase)
test_rec = yield htf.Test(phase)
self.assertTestFail(test_rec)
self.assertEqual([htf.Diagnosis(BadResult.ONE, 'Oh no!', is_failure=True)],
test_rec.diagnoses)
def test_phase_multiple_diagnoses__same_result(self):
@htf.PhaseDiagnoser(OkayResult)
def multi_diag(phase_record):
del phase_record # Unused.
return [
htf.Diagnosis(OkayResult.FINE, 'Fine1'),
htf.Diagnosis(OkayResult.FINE, 'Fine2'),
]
phase = htf.diagnose(multi_diag)(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomePass(phase_rec)
self.assertEqual([OkayResult.FINE, OkayResult.FINE],
phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
store = self.get_diagnoses_store()
self.assertEqual(
htf.Diagnosis(OkayResult.FINE, 'Fine2'),
store.get_diagnosis(OkayResult.FINE))
self.assertEqual([
htf.Diagnosis(OkayResult.FINE, 'Fine1'),
htf.Diagnosis(OkayResult.FINE, 'Fine2'),
], self.last_test_state.test_record.diagnoses)
def test_phase_multiple_diagnoses_from_multiple_diagnosers(self):
@htf.PhaseDiagnoser(OkayResult)
def fine_diag(phase_record):
del phase_record # Unused.
return htf.Diagnosis(OkayResult.FINE, 'Fine')
@htf.PhaseDiagnoser(OkayResult)
def great_diag(phase_record):
del phase_record # Unused.
return htf.Diagnosis(OkayResult.GREAT, 'Great')
phase = htf.diagnose(fine_diag, great_diag)(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomePass(phase_rec)
self.assertEqual([OkayResult.FINE, OkayResult.GREAT],
phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
store = self.get_diagnoses_store()
self.assertEqual(
htf.Diagnosis(OkayResult.FINE, 'Fine'),
store.get_diagnosis(OkayResult.FINE))
self.assertEqual(
htf.Diagnosis(OkayResult.GREAT, 'Great'),
store.get_diagnosis(OkayResult.GREAT))
def test_diagnose_decorator__check_diagnosers_fail(self):
def totally_not_a_diagnoser():
pass
with self.assertRaises(diagnoses_lib.DiagnoserError):
_ = htf.diagnose(totally_not_a_diagnoser)(basic_phase)
def test_always_failed_phase_diagnoser(self):
phase = htf.diagnose(always_fail_phase_diagnoser)(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomeFail(phase_rec)
self.assertPhaseHasFailDiagnosis(phase_rec)
def test_basic_wrapper_diagnoser(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomePass(phase_rec)
self.assertPhaseHasBasicOkayDiagnosis(phase_rec)
def test_phase_diagnoser__phase_error__diag_pass(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(exception_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec, exc_type=PhaseError)
self.assertPhaseOutcomeError(phase_rec)
self.assertPhaseHasBasicOkayDiagnosis(phase_rec)
def test_phase_diagnoser__phase_error__diag_fail(self):
phase = htf.diagnose(fail_phase_diagnoser)(exception_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec, exc_type=PhaseError)
self.assertPhaseOutcomeError(phase_rec)
self.assertPhaseHasFailDiagnosis(phase_rec)
def test_test_record_diagnosis_serialization(self):
phase1 = htf.PhaseOptions(name='pass_diag_phase')(
htf.diagnose(basic_wrapper_phase_diagnoser)(basic_phase))
phase2 = htf.PhaseOptions(name='fail_diag_phase')(
htf.diagnose(fail_phase_diagnoser)(basic_phase))
test = htf.Test(phase1, phase2)
test.add_test_diagnosers(basic_wrapper_test_diagnoser)
test_rec = yield test
self.assertTestFail(test_rec)
self.assertPhaseOutcomePass(test_rec.phases[1])
self.assertPhaseOutcomeFail(test_rec.phases[2])
converted = data.convert_to_base_types(test_rec)
self.assertEqual([
{
'result': 'okay',
'description': 'Everything is okay.',
'component': None,
'priority': 'NORMAL',
},
{
'result': 'bad_one',
'description': 'Oh no!',
'component': None,
'priority': 'NORMAL',
'is_failure': True,
},
{
'result': 'test_ok',
'description': 'Okay',
'component': None,
'priority': 'NORMAL',
},
], converted['diagnoses'])
self.assertEqual(['okay'], converted['phases'][1]['diagnosis_results'])
self.assertEqual([],
converted['phases'][1]['failure_diagnosis_results'])
self.assertEqual([], converted['phases'][2]['diagnosis_results'])
self.assertEqual(['bad_one'],
converted['phases'][2]['failure_diagnosis_results'])
def test_phase_diagnoser_exception__later_diags_still_run_with_fail(self):
phase = htf.diagnose(exception_phase_diag,
fail_phase_diagnoser)(basic_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec, exc_type=DiagPhaseError)
self.assertPhaseOutcomeError(phase_rec)
self.assertPhaseHasFailDiagnosis(phase_rec)
def test_phase_diagnoser_fail__measurement_fail(self):
phase = htf.diagnose(fail_phase_diagnoser)(fail_measurement_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomeFail(phase_rec)
self.assertMeasurementFail(phase_rec, 'bad')
self.assertPhaseHasFailDiagnosis(phase_rec)
def test_phase_diagnoser_pass__measurement_fail(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(fail_measurement_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomeFail(phase_rec)
self.assertMeasurementFail(phase_rec, 'bad')
self.assertPhaseHasBasicOkayDiagnosis(phase_rec)
def test_phase_diagnoser_pass__measurement_pass(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(pass_measurement_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomePass(phase_rec)
self.assertMeasurementPass(phase_rec, 'good')
self.assertPhaseHasBasicOkayDiagnosis(phase_rec)
def test_phase_diagnoser_exception__later_diags_still_run(self):
phase = htf.diagnose(exception_phase_diag,
basic_wrapper_phase_diagnoser)(basic_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec, exc_type=DiagPhaseError)
self.assertPhaseOutcomeError(phase_rec)
self.assertPhaseHasBasicOkayDiagnosis(phase_rec)
def test_phase_diagnoser_exception__measurement_fail(self):
phase = htf.diagnose(exception_phase_diag, basic_wrapper_phase_diagnoser)(
fail_measurement_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec, exc_type=DiagPhaseError)
self.assertPhaseOutcomeError(phase_rec)
self.assertMeasurementFail(phase_rec, 'bad')
self.assertPhaseHasBasicOkayDiagnosis(phase_rec)
def test_basic_phase_diagnoser_on_test(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(basic_phase)
test_rec = yield htf.Test(phase)
self.assertTestPass(test_rec)
self.assertEqual([
htf.Diagnosis(OkayResult.OKAY,
'Everything is okay.',
priority=htf.DiagPriority.NORMAL)
], test_rec.diagnoses)
def test_phase_diagnoser_exception__later_phases_not_run(self):
fail_phase = htf.PhaseOptions(name='fail')(
htf.diagnose(exception_phase_diag)(basic_phase))
not_run_phase = htf.PhaseOptions(name='not_run')(basic_phase)
test_rec = yield htf.Test(fail_phase, not_run_phase)
self.assertTestError(test_rec)
self.assertPhaseError(test_rec.phases[1], exc_type=DiagPhaseError)
self.assertEqual(2, len(test_rec.phases))
def test_diagnose_decorator_later(self):
def phase_func():
pass
phase = htf.measures('m')(
htf.diagnose(basic_wrapper_phase_diagnoser)(phase_func))
self.assertEqual(
htf.PhaseDescriptor(phase_func,
measurements=[htf.Measurement('m')],
diagnosers=[basic_wrapper_phase_diagnoser]),
phase)
def test_phase_diagnoser__wrong_result_type_list(self):
@htf.PhaseDiagnoser(OkayResult)
def bad_result(phase_record):
del phase_record # Unused.
return [htf.Diagnosis(BadResult.ONE, 'one')]
phase = htf.diagnose(bad_result)(basic_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec,
exc_type=diagnoses_lib.InvalidDiagnosisError)
def test_phase_diagnoser__single_not_diagnosis_list(self):
@htf.PhaseDiagnoser(BadResult)
def not_diag(phase_record):
del phase_record # Unused.
return [BadResult.ONE]
phase = htf.diagnose(not_diag)(basic_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec,
exc_type=diagnoses_lib.InvalidDiagnosisError)
def test_phase_diagnoser__internal_not_recorded_on_test_record(self):
@htf.PhaseDiagnoser(OkayResult)
def internal_diag(phase_record):
del phase_record # Unused.
return htf.Diagnosis(OkayResult.OKAY, 'internal', is_internal=True)
phase = htf.diagnose(internal_diag)(basic_phase)
test_rec = yield htf.Test(phase)
self.assertTestPass(test_rec)
self.assertEqual([], test_rec.diagnoses)
phase_rec = test_rec.phases[1]
self.assertEqual([OkayResult.OKAY], phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
def test_test_diagnosis_pass__phase_diagnosis_fail(self):
phase = htf.diagnose(fail_phase_diagnoser)(basic_phase)
test = htf.Test(phase)
test.add_test_diagnosers(basic_wrapper_test_diagnoser)
test_rec = yield test
self.assertTestFail(test_rec)
self.assertEqual([
htf.Diagnosis(BadResult.ONE, 'Oh no!', is_failure=True),
htf.Diagnosis(OkayResult.TEST_OK, 'Okay'),
], test_rec.diagnoses)
phase_rec = test_rec.phases[1]
self.assertEqual([], phase_rec.diagnosis_results)
self.assertEqual([BadResult.ONE], phase_rec.failure_diagnosis_results)
def test_test_diagnosis_fail__phase_diagnosis_pass(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(basic_phase)
test = htf.Test(phase)
test.add_test_diagnosers(fail_test_diagnoser)
test_rec = yield test
self.assertTestFail(test_rec)
self.assertEqual([
htf.Diagnosis(OkayResult.OKAY, 'Everything is okay.'),
htf.Diagnosis(BadResult.TWO, 'Uh oh!', is_failure=True),
], test_rec.diagnoses)
phase_rec = test_rec.phases[1]
self.assertEqual([OkayResult.OKAY], phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
def test_test_diagnosis_pass__phase_diagnosis_pass(self):
phase = htf.diagnose(basic_wrapper_phase_diagnoser)(basic_phase)
test = htf.Test(phase)
test.add_test_diagnosers(basic_wrapper_test_diagnoser)
test_rec = yield test
self.assertTestPass(test_rec)
self.assertEqual([
htf.Diagnosis(OkayResult.OKAY, 'Everything is okay.'),
htf.Diagnosis(OkayResult.TEST_OK, 'Okay'),
], test_rec.diagnoses)
phase_rec = test_rec.phases[1]
self.assertEqual([OkayResult.OKAY], phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
def test_phase_no_diagnoses(self):
@htf.PhaseDiagnoser(BadResult)
def no_result(phase_record):
del phase_record # Unused.
return None
phase = htf.diagnose(no_result)(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomePass(phase_rec)
self.assertEqual([no_result], phase_rec.diagnosers)
self.assertEqual([], phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
store = self.get_diagnoses_store()
self.assertEqual(0, len(store._diagnoses_by_results))
self.assertEqual(0, len(store._diagnoses))
def test_phase_diagnoser_exception__generator_exceptions_after_add(self):
@htf.PhaseDiagnoser(BadResult)
def generate_diag_then_error(phase_record):
del phase_record # Unused.
yield htf.Diagnosis(BadResult.ONE, 'Bad!', is_failure=True)
raise DiagPhaseError('it fatal')
phase = htf.diagnose(generate_diag_then_error)(basic_phase)
phase_rec = yield phase
self.assertPhaseError(phase_rec, exc_type=DiagPhaseError)
self.assertPhaseOutcomeError(phase_rec)
self.assertEqual([], phase_rec.diagnosis_results)
self.assertEqual([BadResult.ONE], phase_rec.failure_diagnosis_results)
store = self.get_diagnoses_store()
self.assertEqual(htf.Diagnosis(BadResult.ONE, 'Bad!', is_failure=True),
store.get_diagnosis(BadResult.ONE))
def test_basic_subclass_diagnoser(self):
class SubclassBasicPhaseDiagnoser(diagnoses_lib.BasePhaseDiagnoser):
def __init__(self):
super(SubclassBasicPhaseDiagnoser,
self).__init__(OkayResult,
name='SubclassBasicPhaseDiagnoser')
def run(self, phase_record):
del phase_record # Unused.
return htf.Diagnosis(OkayResult.FINE, 'Everything is fine.')
phase = htf.diagnose(SubclassBasicPhaseDiagnoser())(basic_phase)
phase_rec = yield phase
self.assertPhaseContinue(phase_rec)
self.assertPhaseOutcomePass(phase_rec)
self.assertEqual([OkayResult.FINE], phase_rec.diagnosis_results)
self.assertEqual([], phase_rec.failure_diagnosis_results)
store = self.get_diagnoses_store()
self.assertEqual(htf.Diagnosis(OkayResult.FINE, 'Everything is fine.'),
store.get_diagnosis(OkayResult.FINE))
