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)
