def __call__(self, context, value): observation = value valid = False error = None comment = None for error in observation.errors: comment = self._error_comment_or_none(error) if comment != None: valid = True break if valid: result = ObservationFailedError(valid=True, failures=[error]) map_attempt = jp.ObjectResultMapAttempt(observation, result) good_results = [map_attempt] bad_results = [] else: comment = self._error_not_found_comment(observation) result = jp.PredicateResult(valid=False, comment=comment) map_attempt = jp.ObjectResultMapAttempt(observation, result) good_results = [] bad_results = [map_attempt] return ov.ObservationVerifyResult(valid=valid, observation=observation, good_results=good_results, bad_results=bad_results, failed_constraints=[], comment=comment)
def __do_test_observation_failure_verifier_with_error(self, klass): context = ExecutionContext() valid = klass == IOError error = klass('Could not connect') observation = jc.Observation() observation.add_error(error) verifier = TestIoErrorFailureVerifier('Test') result = verifier(context, observation) self.assertEqual(valid, result.valid) if valid: attempt = jp.ObjectResultMapAttempt( observation, jc.ObservationFailedError([error], valid=valid)) self.assertFalse(result.bad_results) self.assertEqual([attempt], result.good_results) self.assertEqual('HAVE Could not connect', result.comment) else: attempt = jp.ObjectResultMapAttempt( observation, jp.PredicateResult(valid=False, comment='Expected error was not found.')) self.assertFalse(result.good_results) self.assertEqual([attempt], result.bad_results) self.assertEqual('Expected error was not found.', result.comment)
def test_map_predicate_good_and_bad_min_2(self): aA = jp.PathPredicate('a', jp.STR_EQ('A')) expect_result = mp.MapPredicateResult( valid=False, pred=aA, obj_list=[_NUMBER_DICT, _LETTER_DICT], all_results=[aA(_NUMBER_DICT), aA(_LETTER_DICT)], good_map=[mp.ObjectResultMapAttempt(_LETTER_DICT, aA(_LETTER_DICT))], bad_map=[mp.ObjectResultMapAttempt(_NUMBER_DICT, aA(_NUMBER_DICT))]) self._try_map( aA, [_NUMBER_DICT, _LETTER_DICT], False, expect_result, min=2)
def test_map_predicate_good_and_bad_min_1(self): aA = jp.PathPredicate('a', jp.STR_EQ('A')) aa_number_attempt = mp.ObjectResultMapAttempt(_NUMBER_DICT, aA(_NUMBER_DICT)) aa_letter_attempt = mp.ObjectResultMapAttempt(_LETTER_DICT, aA(_LETTER_DICT)) expect_result = mp.MapPredicateResult( valid=True, pred=aA, obj_list=[_NUMBER_DICT, _LETTER_DICT], all_results=[aa_number_attempt.result, aa_letter_attempt.result], good_map=[aa_letter_attempt], bad_map=[aa_number_attempt]) self._try_map(aA, [_NUMBER_DICT, _LETTER_DICT], True, expect_result)
def test_obsolete_observation_failure_not_ok(self): error_text = 'the error' context = ExecutionContext() observation = jc.Observation() error = ValueError('not the error') observation.add_error(error) failure_verifier = TestObsoleteObservationFailureVerifier( 'Test', error_text) comment = failure_verifier._error_not_found_comment(observation) failure_pred_result = jp.PredicateResult(valid=False, comment=comment) expect_failure = jc.ObservationVerifyResult( valid=False, observation=observation, bad_results=[jp.ObjectResultMapAttempt(observation, failure_pred_result)], good_results=[], failed_constraints=[], comment=comment) self.assertEqual(expect_failure, failure_verifier(context, observation)) builder = jc.ObservationVerifierBuilder(title='Test Verifier') builder.EXPECT(failure_verifier) verifier = builder.build() expect = jc.ObservationVerifyResult( valid=False, observation=observation, bad_results=expect_failure.bad_results, good_results=[], failed_constraints=[]) got = verifier(context, observation) self.assertEqual(expect, got)
def test_obsolete_observation_failure_ok(self): error_text = 'the error' context = ExecutionContext() observation = jc.Observation() error = ValueError(error_text) observation.add_error(error) failure_verifier = TestObsoleteObservationFailureVerifier( 'Test', error_text) failure_pred_result = jc.ObservationFailedError([error], valid=True) expect_failure = jc.ObservationVerifyResult( valid=True, observation=observation, good_results=[jp.ObjectResultMapAttempt(observation, failure_pred_result)], bad_results=[], failed_constraints=[], comment=_TEST_FOUND_ERROR_COMMENT) got = failure_verifier(context, observation) self.assertEqual(expect_failure, got) builder = jc.ObservationVerifierBuilder(title='Test') builder.EXPECT(failure_verifier) verifier = builder.build() expect = jc.ObservationVerifyResult( valid=True, observation=observation, good_results=expect_failure.good_results, bad_results=[], failed_constraints=[]) got = verifier(context, observation) self.assertEqual(expect, got)
def test_map_predicate_good_and_bad_min_indirect(self): context = ExecutionContext(min=2) aA = jp.PathPredicate('a', jp.STR_EQ('A')) expect_result = jp.MapPredicateResult( valid=False, pred=aA, obj_list=[_NUMBER_DICT, _LETTER_DICT], all_results=[aA(context, _NUMBER_DICT), aA(context, _LETTER_DICT)], good_map=[jp.ObjectResultMapAttempt(_LETTER_DICT, aA(context, _LETTER_DICT))], bad_map=[jp.ObjectResultMapAttempt(_NUMBER_DICT, aA(context, _NUMBER_DICT))]) self._try_map( context, aA, [_NUMBER_DICT, _LETTER_DICT], False, expect_result, min=lambda x: x['min'])
def _makeObservationVerifyResult( valid, observation=None, good_results=None, bad_results=None, failed_constraints=None): default_result = jp.PredicateResult(valid=valid) good_results = good_results or ([default_result] if valid else []) bad_results = bad_results or ([] if valid else [default_result]) failed_constraints = failed_constraints or [] observation = observation or jc.Observation() good_attempt_results = [jp.ObjectResultMapAttempt(observation, result) for result in good_results] bad_attempt_results = [jp.ObjectResultMapAttempt(observation, result) for result in bad_results] return jc.ObservationVerifyResult( valid=valid, observation=observation, good_results=good_attempt_results, bad_results=bad_attempt_results, failed_constraints=failed_constraints)
def test_map_predicate_good_1(self): aA = jp.PathPredicate('a', jp.STR_EQ('A')) aA_attempt = mp.ObjectResultMapAttempt(_LETTER_DICT, aA(_LETTER_DICT)) expect_result = mp.MapPredicateResult( valid=True, pred=aA, obj_list=[_LETTER_DICT], all_results=[aA_attempt.result], good_map=[aA_attempt], bad_map=[]) self._try_map(aA, _LETTER_DICT, True, expect_result)
def test_map_not_found(self): aA = jp.PathPredicate('a', jp.STR_EQ('A')) aa_composite_attempt = mp.ObjectResultMapAttempt(_COMPOSITE_DICT, aA(_COMPOSITE_DICT)) expect_result = mp.MapPredicateResult( valid=False, pred=aA, obj_list=[_COMPOSITE_DICT], all_results=[aa_composite_attempt.result], bad_map=[aa_composite_attempt], good_map=[]) self._try_map(aA, _COMPOSITE_DICT, False, expect_result)
def test_map_predicate_bad(self): context = ExecutionContext() aA = jp.PathPredicate('a', jp.STR_EQ('A')) expect_result = jp.MapPredicateResult( valid=False, pred=aA, obj_list=[_NUMBER_DICT], all_results=[aA(context, _NUMBER_DICT)], bad_map=[jp.ObjectResultMapAttempt(_NUMBER_DICT, aA(context, _NUMBER_DICT))], good_map=[]) self._try_map(context, aA, _NUMBER_DICT, False, expect_result)
def test_observation_failure_verifier_without_error(self): observation = jc.Observation() verifier = TestIoErrorFailureVerifier('Test') result = verifier(observation) self.assertFalse(result.valid) # Because has no error self.assertFalse(result.good_results) attempt_list = result.bad_results self.assertEqual([ jp.ObjectResultMapAttempt( observation, jp.PredicateResult(valid=False, comment='Observation had no errors.')) ], result.bad_results)