def test_composite_filter_from_repr(property_filters):
original_filter = CompositeFilter(
operator=CompositeFilterOperator.AND,
filters=[Filter(property_filters[0]),
Filter(property_filters[1])])
data = {
'op':
original_filter.operator,
'filters': [
{
'propertyFilter': {
'property': {
'name':
original_filter.filters[0].inner_filter.prop
},
'op': original_filter.filters[0].inner_filter.operator,
'value': property_filters[0].value.to_repr()
}
},
{
'propertyFilter': {
'property': {
'name':
original_filter.filters[1].inner_filter.prop
},
'op': original_filter.filters[1].inner_filter.operator,
'value': property_filters[1].value.to_repr()
}
},
]
}
output_filter = CompositeFilter.from_repr(data)
assert output_filter == original_filter
def test_filter_from_repr(composite_filter):
original_filter = Filter(inner_filter=composite_filter)
data = {'compositeFilter': original_filter.inner_filter.to_repr()}
output_filter = Filter.from_repr(data)
assert output_filter == original_filter
def test_filter_from_repr_unexpected_filter_name():
unexpected_filter_name = 'unexpectedFilterName'
data = {unexpected_filter_name: 'DoesNotMatter'}
with pytest.raises(ValueError) as ex_info:
Filter.from_repr(data)
assert unexpected_filter_name in ex_info.value.args[0]
def test_property_filter_to_repr(self, property_filters):
property_filter = property_filters[0]
query_filter = Filter(inner_filter=property_filter)
r = query_filter.to_repr()
self._assert_is_correct_prop_dict_for_property_filter(
r['propertyFilter'], property_filter)
def test_query(creds, kind, project):
# type: (str, str, str) -> None
with requests.Session() as s:
ds = Datastore(project=project, service_file=creds, session=s)
property_filter = PropertyFilter(prop='value',
operator=PropertyFilterOperator.EQUAL,
value=Value(42))
query = Query(kind=kind, query_filter=Filter(property_filter))
before = ds.runQuery(query, session=s)
num_results = len(before.entity_results)
transaction = ds.beginTransaction(session=s)
mutations = [
ds.make_mutation(Operation.INSERT,
Key(project, [PathElement(kind)]),
properties={'value': 42}),
ds.make_mutation(Operation.INSERT,
Key(project, [PathElement(kind)]),
properties={'value': 42}),
]
ds.commit(mutations, transaction=transaction, session=s)
# TODO: figure out why this is flaky without the sleep
# Seems to only be flaky intermittently in py2.
time.sleep(2)
after = ds.runQuery(query, session=s)
assert len(after.entity_results) == num_results + 2
def test_composite_filter_to_repr(self, property_filters):
composite_filter = CompositeFilter(
operator=CompositeFilterOperator.AND,
filters=[Filter(property_filters[0]),
Filter(property_filters[1])])
query_filter = Filter(composite_filter)
r = query_filter.to_repr()
composite_filter_dict = r['compositeFilter']
assert composite_filter_dict['op'] == 'AND'
self._assert_is_correct_prop_dict_for_property_filter(
composite_filter_dict['filters'][0]['propertyFilter'],
property_filters[0])
self._assert_is_correct_prop_dict_for_property_filter(
composite_filter_dict['filters'][1]['propertyFilter'],
property_filters[1])
def query_filter(composite_filter):
# type: (CompositeFilter) -> Filter
return Filter(inner_filter=composite_filter)
def composite_filter(property_filters):
# type: (List[PropertyFilter]) -> CompositeFilter
return CompositeFilter(
operator=CompositeFilterOperator.AND,
filters=[Filter(property_filters[0]),
Filter(property_filters[1])])
def test_filter_to_repr(composite_filter):
test_filter = Filter(inner_filter=composite_filter)
r = test_filter.to_repr()
assert r['compositeFilter'] == test_filter.inner_filter.to_repr()
def query_filter():
# type: () -> Filter
inner_filter = PropertyFilter(prop='property_name',
operator=PropertyFilterOperator.EQUAL,
value=Value(123))
return Filter(inner_filter)