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):