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
