def test_list_match_unique_bad(self): context = ExecutionContext() source = [1, 2] want = [jp.NUM_EQ(1), jp.NUM_NE(2)] match_pred = jp.LIST_MATCHES(want, unique=True) result = match_pred(context, source) expect = (jp.SequencedPredicateResultBuilder(match_pred).append_result( jp.MapPredicate(jp.NUM_EQ(1))(context, source)).append_result( jp.MapPredicate(jp.NUM_NE(2))(context, source)).build(True)) self.assertTrue(result) self.assertEquals(expect, result)
def test_list_match_ok_and_bad(self): context = ExecutionContext() source = [1, 2, 3] want = [jp.NUM_EQ(1), jp.NUM_EQ(-1), jp.NUM_EQ(3)] result = jp.LIST_MATCHES(want)(context, source) expect = (jp.SequencedPredicateResultBuilder( jp.LIST_MATCHES(want)).append_result( jp.MapPredicate(jp.NUM_EQ(1))(context, source)).append_result( jp.MapPredicate(jp.NUM_EQ(-1))( context, source)).append_result( jp.MapPredicate(jp.NUM_EQ(3))( context, source)).build(False)) self.assertFalse(result) self.assertEquals(expect, result)
def _try_map(self, context, pred, obj, expect_ok, expect_map_result=None, dump=False, min=1): """Helper function for invoking finder and asserting the result. Args: pred: The jp.ValuePredicate to map. obj: The object to apply the predicate to. expect_ok: Whether we expect apply to succeed or not. expect_map_result: If not None, then the expected jp.MapPredicateResult from apply(). dump: If True then print the filter_result to facilitate debugging. """ map_result = jp.MapPredicate(pred, min=min)(context, obj) if dump: print 'MAP_RESULT:\n{0}\n'.format( JsonSnapshotHelper.ValueToEncodedJson(map_result)) if expect_map_result: self.assertEqual(expect_map_result, map_result) error_msg = '{expect_ok} != {ok}\n{map_result}'.format( expect_ok=expect_ok, ok=map_result.__nonzero__(), map_result=map_result) self.assertEqual(expect_ok, map_result.__nonzero__(), error_msg)
def test_list_match_simple_ok(self): context = ExecutionContext() source = [1, 2] want = [jp.NUM_EQ(1)] result = jp.LIST_MATCHES(want)(context, source) expect = (jp.SequencedPredicateResultBuilder( jp.LIST_MATCHES(want)).append_result( jp.MapPredicate(jp.NUM_EQ(1))(context, source)).build(True)) self.assertTrue(result) self.assertEquals(expect, result)
def test_list_match_strict_bad(self): context = ExecutionContext() source = [1, 2] want = [jp.NUM_NE(2)] match_pred = jp.LIST_MATCHES(want, strict=True) result = match_pred(context, source) expect = (jp.SequencedPredicateResultBuilder(match_pred).append_result( jp.MapPredicate(jp.NUM_NE(2))(context, source)).append_result( jp.UnexpectedPathError(source=source, target_path='[1]', path_value=jp.PathValue( '[1]', 2))).build(False)) self.assertFalse(result) self.assertEquals(expect, result)
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)