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))