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_obsolete_observation_failure_or_found(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_error(ValueError('not the error'))
failure_verifier = TestObsoleteObservationFailureVerifier(
'Verify', 'NotFound')
comment = failure_verifier._error_not_found_comment(observation)
failure_result = jp.PredicateResult(valid=False, comment=comment)
# We've already established this result is what we expect
bad_observation_result = failure_verifier(context, observation)
success_pred_result = jp.PredicateResult(valid=True)
good_observation_result = _makeObservationVerifyResult(
valid=True,
good_results=[success_pred_result],
observation=observation)
success_verifier = FakeObservationVerifier(
'Found', dnf_verifier=[], result=good_observation_result)
builder = jc.ObservationVerifierBuilder(title='Observation Verifier')
builder.EXPECT(failure_verifier).OR(success_verifier)
verifier = builder.build()
expect = jc.ObservationVerifyResult(
valid=True, observation=observation,
bad_results=bad_observation_result.bad_results,
good_results=good_observation_result.good_results,
failed_constraints=[])
got = verifier(context, observation)
self.assertEqual(expect, got)
def test_observation_failure_or_found(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object(_LETTER_DICT)
failure_predicate = jc.ObservationErrorPredicate(
jp.ExceptionMatchesPredicate(ValueError, regex='an error'))
failure_result = failure_predicate(context, observation)
self.assertFalse(failure_result)
good_predicate = jc.ObservationValuePredicate(
jp.PathPredicate('a', jp.STR_EQ('A')))
builder = jc.ObservationVerifierBuilder('TestAddConstraint')
verifier = (
builder.EXPECT(failure_predicate).OR(good_predicate).build())
expect = jc.ObservationVerifyResult(
valid=True,
observation=observation,
bad_results=[failure_result],
good_results=[good_predicate(context, observation)],
failed_constraints=[])
got = verifier(context, observation)
self.assertEqual(expect, got)
def test_observation_failure_ok(self):
error_text = 'the error'
context = ExecutionContext()
observation = jc.Observation()
error = ValueError(error_text)
observation.add_error(error)
ex_pred = jp.ExceptionMatchesPredicate(ValueError, error_text)
ex_result = ex_pred(context, error)
ex_observation_predicate_result = jc.ObservationPredicateResult(
True, observation, jp.LIST_MATCHES([ex_pred]),
jp.LIST_MATCHES([ex_pred])(context, [error]))
expect_failure = jc.ObservationVerifyResult(
valid=True,
observation=observation,
good_results=[ex_observation_predicate_result],
bad_results=[],
failed_constraints=[])
builder = jc.ValueObservationVerifierBuilder(title='Test For Error')
builder.EXPECT(jc.ObservationErrorPredicate(jp.LIST_MATCHES([ex_pred
])))
verifier = builder.build()
self.assertEqual(expect_failure, verifier(context, observation))
def test_assertVerifyResults_ok(self):
observation = jc.Observation()
verify_results = jc.ObservationVerifyResult(valid=True,
observation=observation,
good_results=[],
bad_results=[],
failed_constraints=[])
self.assertVerifyResults(verify_results)
def test_assertVerifyResults_failed(self):
observation = jc.Observation()
verify_results = jc.ObservationVerifyResult(valid=False,
observation=observation,
good_results=[],
bad_results=[],
failed_constraints=[])
self.assertRaises(AssertionError, self.assertVerifyResults,
verify_results)
def _makeObservationVerifyResult(valid,
good_results=None,
bad_results=None,
failed_constraints=None):
good_results = good_results or []
bad_results = bad_results or []
failed_constraints = failed_constraints or []
return jc.ObservationVerifyResult(valid=valid,
observation=jc.Observation(),
good_results=[],
bad_results=[],
failed_constraints=[])
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 __call__(self, context, observation):
return jc.ObservationVerifyResult(valid=self.__valid,
observation=observation,
good_results=[],
bad_results=[],
failed_constraints=[])
