def test_condition_fail(self):
aA = jp.PathEqPredicate('a', 'A')
b2 = jp.PathEqPredicate('b', '2')
ifAthen2 = jc.IF(aA, b2)
demorgan = jc.OR([jc.NOT(aA), b2])
expect = demorgan(_LETTER_DICT)
result = ifAthen2(_LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_disjunction_true_aborts_early(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
disjunction = jc.OR([aA, bB])
expect = jc.SequencedPredicateResult(
valid=True, pred=disjunction, results=[aA(context, _LETTER_DICT)])
result = disjunction(context, _LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_disjunction_true_aborts_early(self):
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
disjunction = jc.OR([aA, bB])
expect = jc.CompositePredicateResult(valid=True,
pred=disjunction,
results=[aA(_LETTER_DICT)])
result = disjunction(_LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_disjunction_false(self):
context = ExecutionContext()
a1 = jp.PathEqPredicate('a', 1)
b2 = jp.PathEqPredicate('b', 2)
disjunction = jc.OR([a1, b2])
expect = jc.CompositePredicateResult(
valid=False, pred=disjunction,
results=[a1(context, _LETTER_DICT), b2(context, _LETTER_DICT)])
result = disjunction(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_condition_success(self):
aA = jp.PathEqPredicate('a', 'A')
bB = jp.PathEqPredicate('b', 'B')
ifAthenB = jc.IF(aA, bB)
demorgan = jc.OR([jc.NOT(aA), bB])
test_cases = [_LETTER_DICT, {'a': 'X', 'b': 'Y'}, {'a': 'X', 'b': 'B'}]
for test in test_cases:
expect = demorgan(test)
result = ifAthenB(test)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_condition_indirect_success(self):
context = ExecutionContext(a='A', b='B')
aA = jp.PathEqPredicate('a', lambda x: x['a'])
bB = jp.PathEqPredicate('b', lambda x: x['b'])
ifAthenB = jc.IF(aA, bB)
demorgan = jc.OR([jc.NOT(aA), bB])
test_cases = [_LETTER_DICT, {'a':'X', 'b':'Y'}, {'a':'X', 'b':'B'}]
for test in test_cases:
expect = demorgan(context, test)
result = ifAthenB(context, test)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_not_success(self):
context = ExecutionContext()
a1 = jp.PathEqPredicate('a', '1')
not_a1 = jc.NOT(a1)
expect = jc.CompositePredicateResult(
valid=True, pred=not_a1, results=[a1(context, _LETTER_DICT)])
result = not_a1(context, _LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
b2 = jp.PathEqPredicate('b', '2')
b2_or_a1 = jc.OR([b2, a1])
not_b2_or_a1 = jc.NOT(b2_or_a1)
expect = jc.CompositePredicateResult(
valid=True, pred=not_b2_or_a1,
results=[b2_or_a1(context, _LETTER_DICT)])
result = not_b2_or_a1(context, _LETTER_DICT)
self.assertTrue(result)
self.assertEqual(expect, result)
def test_not_fail(self):
context = ExecutionContext()
aA = jp.PathEqPredicate('a', 'A')
not_aA = jc.NOT(aA)
expect = jc.CompositePredicateResult(
valid=False, pred=not_aA, results=[aA(context, _LETTER_DICT)])
result = not_aA(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
bB = jp.PathEqPredicate('b', 'B')
bB_or_aA = jc.OR([bB, aA])
not_bB_or_aA = jc.NOT(bB_or_aA)
expect = jc.CompositePredicateResult(
valid=False, pred=not_bB_or_aA,
results=[bB_or_aA(context, _LETTER_DICT)])
result = not_bB_or_aA(context, _LETTER_DICT)
self.assertFalse(result)
self.assertEqual(expect, result)
def test_multiple_required(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('A')
observation.add_object('B')
observation.add_object('C')
fake_observer = FakeObserver(observation)
eq_A_or_B = jp.OR([jp.STR_EQ('A'), jp.STR_EQ('B')])
builder = jc.ValueObservationVerifierBuilder('Test Multiple')
builder.contains_path_pred(None, eq_A_or_B, min=2)
clause = jc.ContractClause('TestClause', fake_observer, builder.build())
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
True, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertEqual(True, result.valid)
# pylint: disable=missing-docstring
# pylint: disable=redefined-builtin
import unittest
from citest.base import (ExecutionContext, JsonSnapshotHelper)
from citest.json_predicate import PathValue
import citest.json_predicate as jp
_CAB = ['C', 'A', 'B']
# pylint: disable=invalid-name
_eq_A = jp.STR_EQ('A')
_eq_B = jp.STR_EQ('B')
_eq_X = jp.STR_EQ('X')
_AorX = jp.OR([_eq_A, _eq_X])
_AorB = jp.OR([_eq_A, _eq_B])
class CardinalityPredicateTest(unittest.TestCase):
def assertEqual(self, expect, have, msg=''):
try:
JsonSnapshotHelper.AssertExpectedValue(expect, have, msg)
except AssertionError:
print '\nEXPECT\n{0!r}\n\nGOT\n{1!r}\n'.format(expect, have)
raise
def test_cardinality_bounds_1(self):
context = ExecutionContext()
for min in range(0, 3):
for max in range(0, 3):
