def test_load_code_info(self):
        branch = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase, ))
        expected = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase.load_code_info(), ))

        self.assertEqual(expected, branch.load_code_info())
    def test_with_args(self):
        branch = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase, ),
            name='name_{arg}')
        expected = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase.with_args(arg=1), ),
            name='name_1')

        self.assertEqual(expected, branch.with_args(arg=1))
    def test_apply_to_all_phases(self):
        def do_rename(phase):
            return _rename(phase, 'blah_blah')

        branch = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase, ))
        expected = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(do_rename(run_phase), ))

        self.assertEqual(expected, branch.apply_to_all_phases(do_rename))
    def test_with_plugs(self):
        class MyPlug(htf.BasePlug):
            pass

        branch = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase, ),
            name='name_{my_plug.__name__}')
        expected = phase_branches.BranchSequence(
            phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
            nodes=(run_phase.with_plugs(my_plug=MyPlug), ),
            name='name_MyPlug')

        self.assertEqual(expected, branch.with_plugs(my_plug=MyPlug))
 def test_as_dict(self):
     branch = phase_branches.BranchSequence(
         phase_branches.DiagnosisCondition.on_all(BranchDiagResult.SET),
         nodes=(run_phase, ))
     expected = {
         'name': None,
         'nodes': [run_phase._asdict()],
         'diag_condition': {
             'condition': phase_branches.ConditionOn.ALL,
             'diagnosis_results': [BranchDiagResult.SET],
         },
     }
     self.assertEqual(expected, branch._asdict())
Exemple #6
0
    def test_branch_with_log(self):
        diag_cond = phase_branches.DiagnosisCondition.on_all(BranchDiag.ONE)
        branch = phase_branches.BranchSequence(diag_cond, name='branch')
        self.diag_store._add_diagnosis(
            diagnoses_lib.Diagnosis(result=BranchDiag.ONE))

        self.test_exec._execute_phase_branch(branch, None, False)
        self.mock_execute_sequence.assert_called_once_with(branch, None, False)
        self.mock_test_record.add_branch_record.assert_called_once_with(
            test_record.BranchRecord.from_branch(branch, True, mock.ANY))
        self.mock_logger.debug.assert_called_once_with(
            '%s: Branch condition met; running phases.',
            'branch:{}'.format(diag_cond.message))
    def test_branch_not_taken(self):
        nodes = [
            phase_branches.BranchSequence(
                phase_branches.DiagnosisCondition.on_all(
                    BranchDiagResult.NOT_SET), run_phase),
        ]

        test_rec = yield htf.Test(nodes)
        self.assertTestPass(test_rec)
        self._assert_phase_names([], test_rec)
        self.assertEqual([
            test_record.BranchRecord(
                name=None,
                diag_condition=phase_branches.DiagnosisCondition(
                    condition=phase_branches.ConditionOn.ALL,
                    diagnosis_results=(BranchDiagResult.NOT_SET, )),
                branch_taken=False,
                evaluated_millis=mock.ANY)
        ], test_rec.branches)
Exemple #8
0
    def test_branch(self, constructor_name, constructor_diags, results,
                    called):
        diag_cond = getattr(phase_branches.DiagnosisCondition,
                            constructor_name)(*constructor_diags)
        branch = phase_branches.BranchSequence(diag_cond)
        for result in results:
            self.diag_store._add_diagnosis(
                diagnoses_lib.Diagnosis(result=result))

        self.test_exec._execute_phase_branch(branch, None, False)
        if called:
            self.mock_execute_sequence.assert_called_once_with(
                branch, None, False)
            self.mock_logger.debug.assert_called_once_with(
                '%s: Branch condition met; running phases.', diag_cond.message)
        else:
            self.mock_execute_sequence.assert_not_called()
            self.mock_logger.debug.assert_called_once_with(
                '%s: Branch condition NOT met; not running sequence.',
                diag_cond.message)
        self.mock_test_record.add_branch_record.assert_called_once_with(
            test_record.BranchRecord.from_branch(branch, called, mock.ANY))