def test_object_observation_verifier_one_constraint_not_found(self): context = ExecutionContext() pred_list = [jp.PathPredicate('a', jp.STR_EQ('NOT_FOUND'))] # This is our object verifier for these tests. verifier = (jc.ValueObservationVerifierBuilder( 'Cannot find one').contains_match(pred_list).build()) 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(context, observation.objects)) # None of these tests succeed. verify_results = builder.build(False) self.assertEqual(pred_list, verify_results.failed_constraints) try: self._try_verify(context, verifier, observation, False, verify_results) except: print 'testing {0}'.format(test[0]) raise
def test_object_observation_verifier_multiple_constraint_found(self): 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(observation.objects)) # All of these tests succeed. verify_results = builder.build(True) try: self._try_verify(verifier, observation, True, verify_results) except: print 'testing {0}'.format(test[0]) raise
def test_object_observation_verifier_with_conditional(self): # We need strict True here because we want each object to pass # the constraint test. Otherwise, if any object passes, then the whole # observation would pass. This causes a problem when we say that # we dont ever want to see 'name' unless it has a particular 'value'. # Without strict test, we'd allow this to occur as long as another object # satisfied that constraint. # When we use 'excludes', it applies to the whole observation since this # is normally the intent. However, here we are excluding values under # certain context -- "If the 'name' field is 'NAME' then it must contain # a value field 'VALUE'". Excluding name='NAME' everywhere would # not permit the context where value='VALUE' which we want to permit. verifier_builder = jc.ValueObservationVerifierBuilder( title='Test Conditional', strict=True) name_eq_pred = jp.PathEqPredicate('name', 'NAME') value_eq_pred = jp.PathEqPredicate('value', 'VALUE') conditional = jp.IF(name_eq_pred, value_eq_pred) pred_list = [jp.PathPredicate('', conditional)] verifier_builder.add_constraint(conditional) match_name_value_obj = {'name': 'NAME', 'value': 'VALUE'} match_value_not_name_obj = {'name': 'GOOD', 'value': 'VALUE'} match_neither_obj = {'name': 'GOOD', 'value': 'GOOD'} match_name_not_value_obj = {'name': 'NAME', 'value': 'BAD'} # bad test_cases = [(True, [match_name_value_obj, match_neither_obj]), (True, [match_value_not_name_obj, match_neither_obj]), (False, [match_neither_obj, match_name_not_value_obj])] context = ExecutionContext() verifier = verifier_builder.build() for test in test_cases: observation = jc.Observation() result_builder = jc.ObservationVerifyResultBuilder(observation) expect_valid = test[0] obj_list = test[1] observation.add_all_objects(obj_list) result_builder.add_observation_predicate_result( jc.ObservationValuePredicate(conditional)(context, observation)) # All of these tests succeed. verify_results = result_builder.build(expect_valid) try: self._try_verify(context, verifier, observation, expect_valid, verify_results) except: print 'testing {0}'.format(obj_list) raise
def test_result_builder_add_bad_result(self): observation = jc.Observation() observation.add_object('A') pred = jp.PathPredicate(None, jp.STR_EQ('B')) builder = jc.ObservationVerifyResultBuilder(observation) map_pred = jp.MapPredicate(pred) map_result = map_pred(observation.objects) builder.add_map_result(map_result) verify_results = builder.build(False) self.assertFalse(verify_results) self.assertEqual(observation, verify_results.observation) self.assertEqual([], verify_results.good_results) self.assertEqual([pred], verify_results.failed_constraints) self.assertEqual(map_result.bad_object_result_mappings, verify_results.bad_results)
def test_object_observation_verifier_some_but_not_all_constraints_found( self): context = ExecutionContext() pred_list = [ jp.PathPredicate('a', jp.STR_EQ('NOT_FOUND')), jp.PathPredicate('b', jp.STR_EQ('B')) ] # This is our object verifier for these tests. verifier = jc.ValueObservationVerifier(title='Find one of two', 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: pred_result = jp.PathPredicate('', pred)(context, observation.objects) builder.add_path_predicate_result( pred(context, observation.objects)) # None of these tests succeed. verify_results = builder.build(False) try: self._try_verify(context, verifier, observation, False, verify_results) except: print 'testing {0}'.format(test[0]) raise
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.ValueObservationVerifierBuilder('Find Both').EXPECT( pred_list[0]).AND(pred_list[1]).build()) 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_observation_predicate_result( jc.ObservationValuePredicate(pred)(context, observation)) # 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