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=[])