def test_dict_match_multi_bad(self):
context = ExecutionContext()
source = {'a': 'testing', 'n': 10}
want = {'n': jp.NUM_NE(10), 'a': jp.STR_SUBSTR('test')}
result = jp.DICT_MATCHES(want)(context, source)
expect = (jp.KeyedPredicateResultBuilder(
jp.DICT_MATCHES(want)).add_result(
'a',
jp.PathPredicateResultBuilder(
source=source,
pred=jp.STR_SUBSTR('test')).add_result_candidate(
path_value=jp.PathValue('a', 'testing'),
final_result=jp.STR_SUBSTR('test')(
context, 'testing')).build(True)).add_result(
'n',
jp.PathPredicateResultBuilder(
source=source,
pred=jp.NUM_NE(10)).add_result_candidate(
jp.PathValue('n', 10),
jp.NUM_NE(10)(
context,
10)).build(False)).build(False))
self.assertFalse(result)
self.assertEquals(expect, result)
def test_collect_with_dict_subset(self):
# See test_dict_subset_with_array_nodes for comparision.
context = ExecutionContext()
letters = {'a':'A', 'b':'B', 'c':'C'}
numbers = {'a':1, 'b':2}
both = [letters, numbers]
source = {'items': both}
letter_subset_pred = jp.DICT_SUBSET({'a':'A'})
path_pred = jp.PathPredicate('items', pred=letter_subset_pred)
result = path_pred(context, source)
mismatch_error = jp.TypeMismatchError(
expect_type=(int, long, float), got_type=str,
source=source,
target_path=jp.PATH_SEP.join(['items', 'a']),
path_value=PathValue('items[1]', numbers))
valid_result = letter_subset_pred(context, letters).clone_with_source(
source=source, base_target_path='items', base_value_path='items[0]')
self.assertEqual(
# pylint: disable=bad-continuation
jp.PathPredicateResultBuilder(source, path_pred)
.add_result_candidate(PathValue('items[0]', letters), valid_result)
.add_result_candidate(PathValue('items[1]', numbers),
mismatch_error)
.build(True),
result)
def test_cardinality_bounds_2_indirect(self):
predicate = jp.CardinalityPredicate(_AorB,
min=lambda x: x['min'],
max=lambda x: x['max'])
for min in range(0, 3):
for max in range(0, 3):
if min > max:
continue
context = ExecutionContext(min=min, max=max)
expect_ok = min <= 2 and max >= 2
source = _CAB
result = predicate(context, source)
all_results = [
jp.SequencedPredicateResult(
False, _AorB,
[jp.PathValueResult(_CAB, '', PathValue('[0]', 'C'),
valid=False, pred=_eq_A),
jp.PathValueResult(_CAB, '', PathValue('[0]', 'C'),
valid=False, pred=_eq_B)]),
jp.SequencedPredicateResult(
True, _AorB,
[jp.PathValueResult(_CAB, '', PathValue('[1]', 'A'),
valid=True, pred=_eq_A)]),
jp.SequencedPredicateResult(
True, _AorB,
[jp.PathValueResult(_CAB, '', PathValue('[2]', 'B'),
valid=False, pred=_eq_A),
jp.PathValueResult(_CAB, '', PathValue('[2]', 'B'),
valid=True, pred=_eq_B)])]
builder = jp.PathPredicateResultBuilder(
pred=jp.PathPredicate('', _AorB), source=_CAB)
builder.add_result_candidate(PathValue('[0]', 'C'), all_results[0])
builder.add_result_candidate(PathValue('[1]', 'A'), all_results[1])
builder.add_result_candidate(PathValue('[2]', 'B'), all_results[2])
expect_path_result = builder.build(True)
if expect_ok:
self.assertEqual(
jp.ConfirmedCardinalityResult(predicate, expect_path_result),
result)
elif max == 0:
self.assertEqual(
jp.UnexpectedValueCardinalityResult(
predicate, expect_path_result),
result)
else:
self.assertEqual(
jp.FailedCardinalityRangeResult(
predicate, expect_path_result),
result)
def test_dict_match_strict_ok(self):
context = ExecutionContext()
source = {'n': 10}
want = {'n': jp.NUM_LE(20)}
match_pred = jp.DICT_MATCHES(want, strict=True)
result = match_pred(context, source)
expect = (jp.KeyedPredicateResultBuilder(match_pred).add_result(
'n',
jp.PathPredicateResultBuilder(
source=source, pred=jp.NUM_LE(20)).add_result_candidate(
jp.PathValue('n', 10),
jp.NUM_LE(20)(context, 10)).build(True)).build(True))
self.assertTrue(result)
self.assertEquals(expect, result)
def test_dict_match_simple_bad(self):
context = ExecutionContext()
source = {'n': 10}
want = {'n': jp.NUM_NE(10)}
result = jp.DICT_MATCHES(want)(context, source)
expect = (jp.KeyedPredicateResultBuilder(
jp.DICT_MATCHES(want)).add_result(
'n',
jp.PathPredicateResultBuilder(
source=source, pred=jp.NUM_NE(10)).add_result_candidate(
jp.PathValue('n', 10),
jp.NUM_NE(10)(context, 10)).build(False)).build(False))
self.assertFalse(result)
self.assertEquals(expect, result)
def _make_result(use_pred, inner_pred, source, good, invalid, pruned=None):
builder = jp.PathPredicateResultBuilder(source, use_pred)
builder.add_all_path_failures(pruned or [])
for path_value in good:
builder.add_result_candidate(
path_value,
jp.PathValueResult(source=source,
target_path=path_value.path,
pred=inner_pred,
valid=True,
path_value=path_value))
for result in invalid:
path_value = result.path_value
builder.add_result_candidate(path_value, result)
return builder.build(len(good) > 0)
def test_dict_match_strict_bad(self):
context = ExecutionContext()
source = {'n': 10, 'extra': 'EXTRA'}
want = {'n': jp.NUM_LE(20)}
match_pred = jp.DICT_MATCHES(want, strict=True)
result = match_pred(context, source)
expect = (jp.KeyedPredicateResultBuilder(match_pred).add_result(
'n',
jp.PathPredicateResultBuilder(
source=source, pred=jp.NUM_LE(20)).add_result_candidate(
jp.PathValue('n', 10),
jp.NUM_LE(20)(context, 10)).build(True)).add_result(
'extra',
jp.UnexpectedPathError(source=source,
target_path='extra',
path_value=jp.PathValue(
'extra',
'EXTRA'))).build(False))
self.assertFalse(result)
self.assertEquals(expect, result)
def test_cardinality_bounds_1(self):
for min in range(0, 3):
for max in range(0, 3):
if min > max:
continue
predicate = jp.CardinalityPredicate(_AorX, min=min, max=max)
expect_ok = min <= 1 and max >= 1
source = _CAB
result = predicate(source)
all_results = [
jp.CompositePredicateResult(False, _AorX, [
jp.PathValueResult(_CAB,
'',
PathValue('[0]', 'C'),
valid=False,
pred=_eq_A),
jp.PathValueResult(_CAB,
'',
PathValue('[0]', 'C'),
valid=False,
pred=_eq_X)
]),
jp.CompositePredicateResult(True, _AorX, [
jp.PathValueResult(_CAB,
'',
PathValue('[1]', 'A'),
valid=True,
pred=_eq_A)
]),
jp.CompositePredicateResult(False, _AorX, [
jp.PathValueResult(_CAB,
'',
PathValue('[2]', 'B'),
valid=False,
pred=_eq_A),
jp.PathValueResult(_CAB,
'',
PathValue('[2]', 'B'),
valid=False,
pred=_eq_X)
])
]
builder = jp.PathPredicateResultBuilder(pred=jp.PathPredicate(
'', _AorX),
source=_CAB)
builder.add_result_candidate(PathValue('[0]', 'C'),
all_results[0])
builder.add_result_candidate(PathValue('[1]', 'A'),
all_results[1])
builder.add_result_candidate(PathValue('[2]', 'B'),
all_results[2])
expect_path_result = builder.build(True)
if expect_ok:
self.assertEqual(
jp.ConfirmedCardinalityResult(predicate,
expect_path_result),
result)
elif max == 0:
self.assertEqual(
jp.UnexpectedValueCardinalityResult(
predicate, expect_path_result), result)
else:
self.assertEqual(
jp.FailedCardinalityRangeResult(
predicate, expect_path_result), result)
