def test_object_observation_verifier_one_constraint_not_found(self): pred_list = [jp.PathPredicate('a', jp.STR_EQ('NOT_FOUND'))] # This is our object verifier for these tests. verifier = jc.ValueObservationVerifier(title='Cannot find one', constraints=pred_list) test_cases = [('array', _DICT_ARRAY), ('dict', _LETTER_DICT), ('array', _DICT_ARRAY), ('multi', _MULTI_ARRAY)] for test in test_cases: observation = jc.Observation() builder = jc.ObservationVerifyResultBuilder(observation) obj = test[1] if isinstance(test, list): observation.add_all_objects(obj) else: observation.add_object(obj) for pred in pred_list: builder.add_path_predicate_result(pred(observation.objects)) # None of these tests succeed. verify_results = builder.build(False) try: self._try_verify(verifier, observation, False, verify_results) except: print 'testing {0}'.format(test[0]) raise
def test_clause_failure(self): observation = jc.Observation() observation.add_object('B') fake_observer = FakeObserver(observation) eq_A = jp.STR_EQ('A') verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A]) clause = jc.ContractClause('TestClause', fake_observer, verifier) expect_result = jc.contract.ContractClauseVerifyResult( False, clause, verifier(observation)) result = clause.verify() self.assertEqual(expect_result, result) self.assertFalse(result)
def test_clause_success(self): context = ExecutionContext() observation = jc.Observation() observation.add_object('A') fake_observer = FakeObserver(observation) eq_A = jp.STR_EQ('A') verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A]) clause = jc.ContractClause('TestClause', fake_observer, verifier) expect_result = jc.contract.ContractClauseVerifyResult( True, clause, verifier(context, observation)) result = clause.verify(context) self.assertEqual(expect_result, result) self.assertTrue(result)
def test_observation_strict_vs_nonstrict(self): aA = jp.PathEqPredicate('a', 'A') bB = jp.PathEqPredicate('b', 'B') unstrict_object_list = [_NUMBER_DICT, _LETTER_DICT, _MIXED_DICT] unstrict_observation = jc.Observation() unstrict_observation.add_all_objects(unstrict_object_list) strict_object_list = [_LETTER_DICT, {'a': 'A', 'b': 'B', 'x': 'X'}] strict_observation = jc.Observation() strict_observation.add_all_objects(strict_object_list) none_object_list = [_NUMBER_DICT, _MIXED_DICT] none_observation = jc.Observation() none_observation.add_all_objects(none_object_list) # pylint: disable=bad-whitespace test_cases = [ # Name jc.Observation Strict, Unstrict #--------------------------------------------------- ('Strict', strict_observation, True, True), ('Unstrict', unstrict_observation, False, True), ('None', none_observation, False, False) ] # For each of the cases, test it with strict and non-strict verification. context = ExecutionContext() for test in test_cases: name = test[0] observation = test[1] # For this case, check it strict (2) and unstrict (3). for index in [2, 3]: test_strict = index == 2 expected = test[index] verifier = jc.ValueObservationVerifier(title='Verifier', constraints=[aA, bB], strict=test_strict) verify_result = verifier(context, observation) try: self.assertEqual(expected, verify_result.__nonzero__()) except Exception as e: print '*** FAILED case={0}:\n{1}'.format(name, e) print 'GOT {0}'.format(verify_result) raise
def test_contract_success(self): observation = jc.Observation() observation.add_object('A') fake_observer = FakeObserver(observation) eq_A = jp.STR_EQ('A') verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A]) clause = jc.ContractClause('TestClause', fake_observer, verifier) contract = jc.Contract() contract.add_clause(clause) expect_result = jc.contract.ContractVerifyResult( True, [clause.verify()]) result = contract.verify() self.assertEqual(expect_result, result) self.assertTrue(result)
def test_contract_failure(self): context = ExecutionContext() observation = jc.Observation() observation.add_object('B') fake_observer = FakeObserver(observation) eq_A = jp.STR_EQ('A') verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A]) clause = jc.ContractClause('TestClause', fake_observer, verifier) contract = jc.Contract() contract.add_clause(clause) expect_result = jc.contract.ContractVerifyResult( False, [clause.verify(context)]) result = contract.verify(context) self.assertEqual(expect_result, result) self.assertFalse(result)
def test_contract_observation_failure(self): observation = jc.Observation() observation.add_error( jp.PredicateResult(False, comment='Observer Failed')) fake_observer = FakeObserver(observation) eq_A = jp.STR_EQ('A') verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A]) clause = jc.ContractClause('TestClause', fake_observer, verifier) contract = jc.Contract() contract.add_clause(clause) expect_result = jc.contract.ContractVerifyResult( False, [clause.verify()]) result = contract.verify() self.assertEqual(expect_result, result) self.assertFalse(result)
def test_contract_mixed_clause_failure_not_ok(self): observation = jc.Observation() observation.add_object('A') fake_observer = FakeObserver(observation) eq_A = jp.STR_EQ('A') eq_B = jp.STR_EQ('B') verifier = jc.ValueObservationVerifier('Has A and B', constraints=[eq_A, eq_B]) clause = jc.ContractClause('TestClause', fake_observer, verifier) contract = jc.Contract() contract.add_clause(clause) expect_result = jc.contract.ContractVerifyResult( False, [clause.verify()]) result = contract.verify() self.assertEqual(expect_result, result) self.assertFalse(result)
def test_object_observation_verifier_multiple_constraint_found(self): context = ExecutionContext() pred_list = [ jp.PathPredicate('a', jp.STR_EQ('A')), jp.PathPredicate('b', jp.STR_EQ('B')) ] # This is our object verifier for these tests. verifier = jc.ValueObservationVerifier(title='Find Both', constraints=pred_list) test_cases = [('dict', _LETTER_DICT), ('array', _DICT_ARRAY), ('multi', _MULTI_ARRAY)] for test in test_cases: observation = jc.Observation() builder = jc.ObservationVerifyResultBuilder(observation) obj = test[1] if isinstance(test, list): observation.add_all_objects(obj) else: observation.add_object(obj) for pred in pred_list: builder.add_path_predicate_result( pred(context, observation.objects)) # All of these tests succeed. verify_results = builder.build(True) self.assertEqual([], verify_results.failed_constraints) try: self._try_verify(context, verifier, observation, True, verify_results) except: print 'testing {0}'.format(test[0]) raise