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)
